Yi-Coder-1.5B智能体开发：技能集成与优化

最近在折腾AI智能体，发现一个挺有意思的现象：很多开发者一上来就想用几十亿甚至上百亿参数的大模型，觉得参数越大智能体就越“聪明”。但实际用下来，尤其是做技能集成和复杂行为设计时，模型太大反而成了负担——推理慢、资源占用高，调试起来也麻烦。

后来我试了试Yi-Coder-1.5B，这个只有15亿参数的小模型，结果有点出乎意料。它在代码理解和生成上的表现，完全能满足大多数智能体开发的需求，而且因为体积小，部署和优化起来特别灵活。今天就跟大家聊聊，怎么用这个小而强的模型来搭建实用的AI智能体，重点说说技能集成和行为树设计这些实际开发中会遇到的问题。

1. 为什么选择Yi-Coder-1.5B做智能体开发？

先说说我为什么看好这个模型。Yi-Coder-1.5B虽然参数不多，但有几个特点特别适合智能体开发。

首先是它的长上下文能力，最大支持128K的token长度。这意味着你可以把一整个项目的代码、文档、甚至对话历史都塞进去，模型能看得过来。对于智能体来说，这太重要了——你需要它记住之前的操作、理解当前的上下文，然后做出合理的决策。

另一个是它对52种编程语言的支持。智能体开发中，你可能会用到Python写逻辑、JavaScript处理Web交互、SQL查询数据，模型如果只懂一两种语言，那局限性就太大了。Yi-Coder在这方面覆盖得很全，基本上常见的开发语言都包含了。

最重要的是它的效率。1.5B的模型，量化后可能就几百MB，在普通的开发机上就能跑起来，响应速度也快。做智能体开发，尤其是需要频繁调试和迭代的时候，快速反馈比绝对的精度更重要。

我对比过几个同级别的模型，在代码补全、调试、简单算法生成这些智能体常用的任务上，Yi-Coder-1.5B的表现完全不输那些更大的模型，有时候甚至更好。下面这个简单的例子，你就能感受到它的实用性。

# 一个简单的智能体技能：解析用户需求并生成代码框架
from typing import Dict, Any
import json

def analyze_requirement_and_plan(user_input: str) -> Dict[str, Any]:
    """
    分析用户需求，生成开发计划
    这是智能体的核心推理能力
    """
    prompt = f"""
    用户需求：{user_input}
    
    请分析这个需求，并生成一个开发计划，包括：
    1. 需要哪些技能模块
    2. 大概的实现步骤
    3. 可能遇到的难点
    
    用JSON格式返回，包含以下字段：
    - skills: 列表，需要的技能
    - steps: 列表，实现步骤
    - challenges: 列表，可能的问题
    - estimated_time: 字符串，预估时间
    """
    
    # 这里实际会调用Yi-Coder模型
    # 为了演示，我们模拟一个返回
    return {
        "skills": ["文件操作", "API调用", "数据处理", "错误处理"],
        "steps": [
            "1. 创建项目结构",
            "2. 实现核心逻辑模块",
            "3. 添加配置管理",
            "4. 编写测试用例",
            "5. 打包部署"
        ],
        "challenges": ["网络请求稳定性", "大数据处理效率", "错误恢复机制"],
        "estimated_time": "2-3天"
    }

# 测试一下
if __name__ == "__main__":
    requirement = "帮我开发一个自动下载网络图片并压缩的工具"
    plan = analyze_requirement_and_plan(requirement)
    print(json.dumps(plan, indent=2, ensure_ascii=False))

2. 智能体技能集成的实战方法

技能集成是智能体开发的核心。一个智能体能不能用，就看它掌握了多少实用的技能。用Yi-Coder-1.5B来做技能集成，我总结了几种比较有效的方法。

2.1 技能描述与注册机制

首先得有个清晰的方式来定义技能。我习惯用Python的dataclass来封装技能信息，这样结构清晰，也方便扩展。

from dataclasses import dataclass
from typing import Callable, Dict, Any, List
import inspect

@dataclass
class Skill:
    """智能体技能的基础定义"""
    name: str  # 技能名称
    description: str  # 技能描述
    function: Callable  # 对应的函数
    parameters: List[Dict[str, Any]]  # 参数说明
    examples: List[str]  # 使用示例
    
class SkillRegistry:
    """技能注册中心"""
    def __init__(self):
        self.skills: Dict[str, Skill] = {}
    
    def register(self, skill: Skill):
        """注册一个技能"""
        self.skills[skill.name] = skill
        print(f" 技能注册成功: {skill.name}")
    
    def get_skill(self, name: str) -> Skill:
        """获取技能"""
        return self.skills.get(name)
    
    def list_skills(self) -> List[str]:
        """列出所有可用技能"""
        return list(self.skills.keys())
    
    def generate_skill_prompt(self) -> str:
        """生成技能描述的提示词，用于模型理解"""
        prompt = "可用技能列表：\n\n"
        for name, skill in self.skills.items():
            prompt += f"技能名称：{name}\n"
            prompt += f"功能描述：{skill.description}\n"
            prompt += f"参数说明：{skill.parameters}\n"
            prompt += f"使用示例：{', '.join(skill.examples)}\n"
            prompt += "-" * 40 + "\n"
        return prompt

# 定义一些基础技能
def search_web(query: str, max_results: int = 5) -> List[Dict]:
    """搜索网页信息"""
    # 这里应该是实际的搜索实现
    return [{"title": f"结果{i}", "url": f"https://example.com/{i}"} 
            for i in range(min(max_results, 3))]

def read_file(filepath: str) -> str:
    """读取文件内容"""
    try:
        with open(filepath, 'r', encoding='utf-8') as f:
            return f.read()
    except Exception as e:
        return f"读取文件失败：{str(e)}"

def write_file(filepath: str, content: str) -> bool:
    """写入文件"""
    try:
        with open(filepath, 'w', encoding='utf-8') as f:
            f.write(content)
        return True
    except Exception as e:
        print(f"写入文件失败：{str(e)}")
        return False

# 创建技能实例并注册
registry = SkillRegistry()

web_search_skill = Skill(
    name="网页搜索",
    description="在互联网上搜索相关信息",
    function=search_web,
    parameters=[
        {"name": "query", "type": "str", "description": "搜索关键词"},
        {"name": "max_results", "type": "int", "description": "最大结果数", "default": 5}
    ],
    examples=["搜索Python教程", "查找最新的AI新闻"]
)

file_read_skill = Skill(
    name="读取文件",
    description="读取本地文件内容",
    function=read_file,
    parameters=[
        {"name": "filepath", "type": "str", "description": "文件路径"}
    ],
    examples=["读取config.json", "查看日志文件"]
)

registry.register(web_search_skill)
registry.register(file_read_skill)

# 查看可用技能
print("可用技能：", registry.list_skills())
print("\n技能提示词：")
print(registry.generate_skill_prompt()[:500])  # 只打印前500字符

2.2 技能调用与参数解析

有了技能定义，接下来就是怎么让模型学会调用这些技能。这里的关键是让模型理解什么时候该用什么技能，以及怎么传递正确的参数。

import re
import json

class SkillExecutor:
    """技能执行器"""
    def __init__(self, registry: SkillRegistry):
        self.registry = registry
    
    def parse_model_response(self, response: str) -> Dict[str, Any]:
        """
        解析模型的响应，提取技能调用信息
        模型应该返回类似这样的格式：
        {
            "skill": "技能名称",
            "parameters": {"参数1": "值1", "参数2": "值2"},
            "reasoning": "调用这个技能的原因"
        }
        """
        # 尝试解析JSON格式
        try:
            # 查找JSON部分
            json_match = re.search(r'\{.*\}', response, re.DOTALL)
            if json_match:
                return json.loads(json_match.group())
        except json.JSONDecodeError:
            pass
        
        # 如果JSON解析失败，尝试提取关键信息
        result = {"skill": None, "parameters": {}, "reasoning": response}
        
        # 简单的关键词匹配（实际应该用更智能的方法）
        for skill_name in self.registry.list_skills():
            if skill_name in response:
                result["skill"] = skill_name
                break
        
        return result
    
    def execute_skill(self, skill_name: str, parameters: Dict[str, Any]) -> Any:
        """执行具体的技能"""
        skill = self.registry.get_skill(skill_name)
        if not skill:
            return f"错误：找不到技能 '{skill_name}'"
        
        try:
            # 调用技能函数
            return skill.function(**parameters)
        except Exception as e:
            return f"执行技能失败：{str(e)}"
    
    def process_user_request(self, user_input: str, model_response: str) -> str:
        """
        处理用户请求的完整流程
        1. 解析模型响应
        2. 执行技能
        3. 返回结果
        """
        # 解析模型想要调用什么技能
        parsed = self.parse_model_response(model_response)
        
        if not parsed["skill"]:
            return "模型没有指定要调用的技能"
        
        # 执行技能
        result = self.execute_skill(parsed["skill"], parsed.get("parameters", {}))
        
        # 格式化返回结果
        return f"""
技能执行结果：
- 调用的技能：{parsed['skill']}
- 执行参数：{json.dumps(parsed.get('parameters', {}), ensure_ascii=False)}
- 执行结果：{result}
- 模型推理：{parsed.get('reasoning', '无')}
        """

# 使用示例
executor = SkillExecutor(registry)

# 模拟模型响应（实际中这应该来自Yi-Coder模型的输出）
model_response = """
用户想要搜索Python教程，我应该使用网页搜索技能。

{
    "skill": "网页搜索",
    "parameters": {"query": "Python入门教程 2024", "max_results": 3},
    "reasoning": "用户需要学习Python，应该搜索最新的教程资源"
}
"""

user_request = "我想学习Python，有什么好的教程推荐吗？"
result = executor.process_user_request(user_request, model_response)
print(result)

3. 行为树设计与决策优化

智能体不能只是机械地执行技能，它需要有自己的“思考”过程，知道在什么情况下该做什么。这就是行为树发挥作用的地方。

3.1 基础行为树实现

行为树是一种组织智能体行为的方式，它把复杂的决策过程分解成一个个小的节点，通过树状结构来控制执行流程。

from enum import Enum
from typing import List, Optional, Callable

class NodeStatus(Enum):
    """节点状态"""
    SUCCESS = "success"
    FAILURE = "failure"
    RUNNING = "running"

class BehaviorNode:
    """行为树节点基类"""
    def __init__(self, name: str):
        self.name = name
        self.children: List['BehaviorNode'] = []
    
    def add_child(self, child: 'BehaviorNode'):
        """添加子节点"""
        self.children.append(child)
    
    def execute(self, context: Dict[str, Any]) -> NodeStatus:
        """执行节点逻辑"""
        raise NotImplementedError("子类必须实现execute方法")

class SequenceNode(BehaviorNode):
    """顺序节点：所有子节点都成功才算成功"""
    def execute(self, context: Dict[str, Any]) -> NodeStatus:
        print(f"执行顺序节点: {self.name}")
        for child in self.children:
            status = child.execute(context)
            if status != NodeStatus.SUCCESS:
                return status
        return NodeStatus.SUCCESS

class SelectorNode(BehaviorNode):
    """选择节点：有一个子节点成功就算成功"""
    def execute(self, context: Dict[str, Any]) -> NodeStatus:
        print(f"执行选择节点: {self.name}")
        for child in self.children:
            status = child.execute(context)
            if status == NodeStatus.SUCCESS:
                return NodeStatus.SUCCESS
        return NodeStatus.FAILURE

class ActionNode(BehaviorNode):
    """动作节点：执行具体的行为"""
    def __init__(self, name: str, action: Callable):
        super().__init__(name)
        self.action = action
    
    def execute(self, context: Dict[str, Any]) -> NodeStatus:
        print(f"执行动作: {self.name}")
        try:
            result = self.action(context)
            context[f"result_{self.name}"] = result
            return NodeStatus.SUCCESS
        except Exception as e:
            print(f"动作执行失败: {str(e)}")
            return NodeStatus.FAILURE

class ConditionNode(BehaviorNode):
    """条件节点：检查条件是否满足"""
    def __init__(self, name: str, condition: Callable[[Dict], bool]):
        super().__init__(name)
        self.condition = condition
    
    def execute(self, context: Dict[str, Any]) -> NodeStatus:
        print(f"检查条件: {self.name}")
        if self.condition(context):
            return NodeStatus.SUCCESS
        return NodeStatus.FAILURE

# 构建一个简单的智能体行为树
def build_sample_behavior_tree() -> BehaviorNode:
    """构建示例行为树"""
    
    # 根节点：选择节点（尝试不同的策略）
    root = SelectorNode("根节点-策略选择")
    
    # 策略1：直接搜索
    strategy1 = SequenceNode("策略1-直接搜索")
    
    # 检查是否需要搜索
    need_search = ConditionNode(
        "检查是否需要搜索",
        lambda ctx: "搜索" in ctx.get("user_input", "")
    )
    
    # 执行搜索动作
    def search_action(context):
        query = context.get("user_input", "")
        # 这里实际会调用搜索技能
        return f"搜索结果: {query}"
    
    search_node = ActionNode("执行搜索", search_action)
    
    strategy1.add_child(need_search)
    strategy1.add_child(search_node)
    
    # 策略2：读取文件
    strategy2 = SequenceNode("策略2-文件操作")
    
    # 检查是否需要读文件
    need_file = ConditionNode(
        "检查是否需要文件操作",
        lambda ctx: "文件" in ctx.get("user_input", "") or "读取" in ctx.get("user_input", "")
    )
    
    # 执行读文件动作
    def read_file_action(context):
        # 这里实际会调用读文件技能
        return "文件内容示例"
    
    read_node = ActionNode("读取文件", read_file_action)
    
    strategy2.add_child(need_file)
    strategy2.add_child(read_node)
    
    # 策略3：默认回复
    def default_action(context):
        return "我可以帮你搜索信息或读取文件，请告诉我具体需求"
    
    default_node = ActionNode("默认回复", default_action)
    
    # 组装行为树
    root.add_child(strategy1)
    root.add_child(strategy2)
    root.add_child(default_node)
    
    return root

# 测试行为树
if __name__ == "__main__":
    tree = build_sample_behavior_tree()
    
    # 测试不同场景
    test_cases = [
        {"user_input": "帮我搜索Python教程"},
        {"user_input": "读取配置文件"},
        {"user_input": "今天天气怎么样"}
    ]
    
    for i, context in enumerate(test_cases, 1):
        print(f"\n{'='*40}")
        print(f"测试用例 {i}: {context['user_input']}")
        print(f"{'='*40}")
        
        status = tree.execute(context)
        print(f"执行结果: {status.value}")
        print(f"上下文: {context}")

3.2 结合Yi-Coder的智能决策

行为树提供了框架，但具体的决策逻辑可以交给Yi-Coder来生成。这样既能保证行为的结构化，又能利用模型的推理能力。

class LLMEnhancedBehaviorTree:
    """结合大模型的行为树"""
    def __init__(self, skill_registry: SkillRegistry):
        self.skill_registry = skill_registry
        self.behavior_tree = None
    
    def generate_behavior_plan(self, user_input: str, context: Dict[str, Any]) -> str:
        """
        使用Yi-Coder生成行为计划
        模型需要分析当前情况，决定采取什么行动
        """
        skills_prompt = self.skill_registry.generate_skill_prompt()
        
        prompt = f"""
当前情况：
- 用户输入：{user_input}
- 可用技能：{', '.join(self.skill_registry.list_skills())}

请分析用户需求，并生成一个行为计划。
计划应该包括：
1. 需要调用哪些技能（按顺序）
2. 每个技能需要什么参数
3. 预期的结果

用JSON格式返回，例如：
{{
    "plan": [
        {{
            "skill": "技能名称",
            "parameters": {{"参数1": "值1"}},
            "reason": "为什么调用这个技能"
        }}
    ],
    "expected_outcome": "期望的结果"
}}
        """
        
        # 这里实际会调用Yi-Coder模型
        # 模拟返回
        if "搜索" in user_input:
            return '''
{
    "plan": [
        {
            "skill": "网页搜索",
            "parameters": {"query": "Python教程"},
            "reason": "用户需要学习资料，应该搜索相关资源"
        }
    ],
    "expected_outcome": "找到合适的Python学习资源"
}
            '''
        else:
            return '''
{
    "plan": [
        {
            "skill": "读取文件",
            "parameters": {"filepath": "help.txt"},
            "reason": "用户可能需要查看帮助文档"
        }
    ],
    "expected_outcome": "提供相关帮助信息"
}
            '''
    
    def execute_plan(self, plan_json: str, context: Dict[str, Any]) -> str:
        """执行生成的行为计划"""
        try:
            plan = json.loads(plan_json)
            results = []
            
            for step in plan.get("plan", []):
                skill_name = step.get("skill")
                parameters = step.get("parameters", {})
                reason = step.get("reason", "")
                
                # 执行技能
                skill = self.skill_registry.get_skill(skill_name)
                if skill:
                    result = skill.function(**parameters)
                    results.append(f"{skill_name}: {result}")
                else:
                    results.append(f"未知技能: {skill_name}")
            
            return "\n".join(results)
        except Exception as e:
            return f"执行计划失败: {str(e)}"

# 使用示例
enhanced_tree = LLMEnhancedBehaviorTree(registry)

# 用户请求
user_request = "我想学习Python编程"

# 生成行为计划
plan = enhanced_tree.generate_behavior_plan(user_request, {})
print("生成的行为计划：")
print(plan)

# 执行计划
print("\n执行结果：")
result = enhanced_tree.execute_plan(plan, {})
print(result)

4. 性能优化与实用技巧

在实际开发中，性能是个绕不开的话题。Yi-Coder-1.5B虽然小，但用好了也能发挥很大作用。这里分享几个我实践过的优化技巧。

4.1 上下文管理优化

128K的上下文很长，但也不能随便用。合理的上下文管理能显著提升性能。

class ContextManager:
    """智能上下文管理器"""
    def __init__(self, max_tokens: int = 120000):
        self.max_tokens = max_tokens
        self.conversation_history = []
        self.current_context = ""
    
    def add_message(self, role: str, content: str):
        """添加消息到历史"""
        self.conversation_history.append({
            "role": role,
            "content": content,
            "timestamp": len(self.conversation_history)
        })
    
    def compress_history(self, keep_last: int = 10):
        """压缩历史记录，只保留最近的部分"""
        if len(self.conversation_history) > keep_last:
            # 保留系统消息和最近的消息
            system_messages = [m for m in self.conversation_history 
                             if m["role"] == "system"]
            recent_messages = self.conversation_history[-keep_last:]
            self.conversation_history = system_messages + recent_messages
    
    def build_prompt(self, current_task: str) -> str:
        """构建当前任务的提示词"""
        # 基础系统提示
        system_prompt = """你是一个AI智能体，拥有多种技能。
        请根据用户需求，选择合适的技能并执行。
        保持回答简洁、准确。"""
        
        # 构建对话历史
        history_text = ""
        for msg in self.conversation_history[-5:]:  # 只取最近5条
            history_text += f"{msg['role']}: {msg['content']}\n"
        
        # 当前任务
        task_text = f"当前任务：{current_task}"
        
        # 技能列表（从注册中心获取）
        skills_text = "可用技能：网页搜索、读取文件、写入文件"
        
        prompt = f"""
{system_prompt}

对话历史：
{history_text}

{skills_text}

{task_text}

请分析任务，决定需要调用什么技能，并说明理由。
        """
        
        # 估算token数（简化估算）
        estimated_tokens = len(prompt) // 4
        if estimated_tokens > self.max_tokens:
            self.compress_history(keep_last=3)
            return self.build_prompt(current_task)
        
        return prompt
    
    def update_from_response(self, response: str):
        """更新上下文"""
        self.add_message("assistant", response)

# 使用示例
context_mgr = ContextManager()

# 模拟对话
context_mgr.add_message("user", "帮我搜索Python教程")
prompt1 = context_mgr.build_prompt("搜索Python教程")
print("提示词1长度:", len(prompt1))
print(prompt1[:200], "...")

context_mgr.add_message("assistant", "我将使用网页搜索技能查找Python教程")
context_mgr.add_message("user", "再找找数据分析的教程")

prompt2 = context_mgr.build_prompt("搜索数据分析教程")
print("\n提示词2长度:", len(prompt2))
print(prompt2[:200], "...")

4.2 技能缓存与复用

很多技能调用是有规律的，合理的缓存能减少重复计算。

import hashlib
import time
from functools import lru_cache
from datetime import datetime, timedelta

class SkillCache:
    """技能缓存管理器"""
    def __init__(self, ttl_seconds: int = 3600):  # 默认缓存1小时
        self.ttl = ttl_seconds
        self.cache = {}
    
    def _generate_key(self, skill_name: str, parameters: Dict) -> str:
        """生成缓存键"""
        param_str = json.dumps(parameters, sort_keys=True)
        key_str = f"{skill_name}:{param_str}"
        return hashlib.md5(key_str.encode()).hexdigest()
    
    def get(self, skill_name: str, parameters: Dict) -> Optional[Any]:
        """获取缓存结果"""
        key = self._generate_key(skill_name, parameters)
        if key in self.cache:
            entry = self.cache[key]
            # 检查是否过期
            if datetime.now() - entry["timestamp"] < timedelta(seconds=self.ttl):
                print(f"缓存命中: {skill_name}")
                return entry["result"]
            else:
                # 缓存过期，删除
                del self.cache[key]
        return None
    
    def set(self, skill_name: str, parameters: Dict, result: Any):
        """设置缓存"""
        key = self._generate_key(skill_name, parameters)
        self.cache[key] = {
            "result": result,
            "timestamp": datetime.now(),
            "skill": skill_name,
            "params": parameters
        }
        print(f"缓存设置: {skill_name}")
    
    def clear_expired(self):
        """清理过期缓存"""
        now = datetime.now()
        expired_keys = []
        for key, entry in self.cache.items():
            if now - entry["timestamp"] > timedelta(seconds=self.ttl):
                expired_keys.append(key)
        
        for key in expired_keys:
            del self.cache[key]
        
        print(f"清理了 {len(expired_keys)} 个过期缓存")

# 带缓存的技能执行器
class CachedSkillExecutor(SkillExecutor):
    def __init__(self, registry: SkillRegistry):
        super().__init__(registry)
        self.cache = SkillCache(ttl_seconds=1800)  # 30分钟缓存
    
    def execute_skill(self, skill_name: str, parameters: Dict[str, Any]) -> Any:
        """带缓存的技能执行"""
        # 先检查缓存
        cached_result = self.cache.get(skill_name, parameters)
        if cached_result is not None:
            return cached_result
        
        # 缓存未命中，执行技能
        skill = self.registry.get_skill(skill_name)
        if not skill:
            return f"错误：找不到技能 '{skill_name}'"
        
        try:
            result = skill.function(**parameters)
            # 缓存结果
            self.cache.set(skill_name, parameters, result)
            return result
        except Exception as e:
            return f"执行技能失败：{str(e)}"

# 测试缓存效果
cache_test_executor = CachedSkillExecutor(registry)

# 第一次执行（会实际执行）
start_time = time.time()
result1 = cache_test_executor.execute_skill("网页搜索", {"query": "Python", "max_results": 3})
time1 = time.time() - start_time
print(f"第一次执行: {time1:.3f}秒")

# 第二次执行相同参数（应该命中缓存）
start_time = time.time()
result2 = cache_test_executor.execute_skill("网页搜索", {"query": "Python", "max_results": 3})
time2 = time.time() - start_time
print(f"第二次执行: {time2:.3f}秒 (缓存命中)")

# 清理缓存
cache_test_executor.cache.clear_expired()

5. 实际应用案例：开发一个代码助手智能体

理论说了这么多，咱们来看一个实际的例子。我最近用Yi-Coder-1.5B开发了一个代码助手智能体，它能帮开发者分析代码问题、生成代码片段、甚至重构代码。

class CodeAssistantAgent:
    """代码助手智能体"""
    def __init__(self):
        self.skill_registry = SkillRegistry()
        self.context_mgr = ContextManager()
        self.executor = CachedSkillExecutor(self.skill_registry)
        
        # 注册代码相关的技能
        self._register_code_skills()
    
    def _register_code_skills(self):
        """注册代码处理技能"""
        
        def analyze_code(code: str, language: str = "python") -> Dict:
            """分析代码问题"""
            # 这里可以集成各种代码分析工具
            issues = []
            
            # 简单的代码检查（实际应该用更专业的工具）
            if "print(" in code and language == "python":
                issues.append("建议使用logging代替print进行调试输出")
            
            if "except:" in code:
                issues.append("避免使用裸except，应该指定异常类型")
            
            return {
                "language": language,
                "line_count": len(code.split('\n')),
                "issues_found": len(issues),
                "issues": issues,
                "suggestion": "代码结构清晰，但可以进一步优化" if not issues else "发现一些问题需要修复"
            }
        
        def generate_code(description: str, language: str = "python") -> str:
            """根据描述生成代码"""
            # 这里实际会调用Yi-Coder模型
            # 模拟返回
            if "排序" in description and language == "python":
                return """
def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)
                """
            else:
                return f"# {description}\n# 代码生成功能待实现"
        
        def refactor_code(code: str, goal: str) -> str:
            """重构代码"""
            # 简单的重构示例
            if "for i in range" in code and "列表推导" in goal:
                # 尝试将for循环改为列表推导
                lines = code.split('\n')
                new_lines = []
                for line in lines:
                    if "for i in range" in line and "append" in lines[lines.index(line)+1]:
                        # 简化示例，实际应该更复杂的解析
                        new_lines.append("# 重构为列表推导")
                        new_lines.append("result = [i*2 for i in range(10)]")
                    else:
                        new_lines.append(line)
                return '\n'.join(new_lines)
            return code
        
        # 注册技能
        code_analysis_skill = Skill(
            name="代码分析",
            description="分析代码质量，发现问题",
            function=analyze_code,
            parameters=[
                {"name": "code", "type": "str", "description": "要分析的代码"},
                {"name": "language", "type": "str", "description": "编程语言", "default": "python"}
            ],
            examples=["分析这段Python代码", "检查代码质量问题"]
        )
        
        code_generation_skill = Skill(
            name="代码生成",
            description="根据描述生成代码",
            function=generate_code,
            parameters=[
                {"name": "description", "type": "str", "description": "代码功能描述"},
                {"name": "language", "type": "str", "description": "编程语言", "default": "python"}
            ],
            examples=["生成快速排序算法", "写一个HTTP请求函数"]
        )
        
        code_refactor_skill = Skill(
            name="代码重构",
            description="改进现有代码结构",
            function=refactor_code,
            parameters=[
                {"name": "code", "type": "str", "description": "原始代码"},
                {"name": "goal", "type": "str", "description": "重构目标"}
            ],
            examples=["优化性能", "提高可读性"]
        )
        
        self.skill_registry.register(code_analysis_skill)
        self.skill_registry.register(code_generation_skill)
        self.skill_registry.register(code_refactor_skill)
    
    def process_request(self, user_input: str) -> str:
        """处理用户请求"""
        # 更新上下文
        self.context_mgr.add_message("user", user_input)
        
        # 分析请求类型
        if "分析" in user_input or "检查" in user_input:
            # 提取代码（这里简化处理）
            code_to_analyze = "print('hello')\ntry:\n    x = 1/0\nexcept:\n    pass"
            result = self.executor.execute_skill(
                "代码分析", 
                {"code": code_to_analyze, "language": "python"}
            )
            response = f"代码分析结果：\n{json.dumps(result, indent=2, ensure_ascii=False)}"
        
        elif "生成" in user_input or "写一个" in user_input:
            # 提取描述
            description = user_input.replace("生成", "").replace("写一个", "").strip()
            result = self.executor.execute_skill(
                "代码生成",
                {"description": description, "language": "python"}
            )
            response = f"生成的代码：\n```python\n{result}\n```"
        
        elif "重构" in user_input or "优化" in user_input:
            code_to_refactor = "result = []\nfor i in range(10):\n    result.append(i*2)"
            result = self.executor.execute_skill(
                "代码重构",
                {"code": code_to_refactor, "goal": "使用列表推导优化"}
            )
            response = f"重构后的代码：\n```python\n{result}\n```"
        
        else:
            response = "我可以帮你分析代码、生成代码片段或重构代码。请告诉我具体需求。"
        
        # 更新上下文
        self.context_mgr.add_message("assistant", response)
        
        return response

# 使用代码助手
assistant = CodeAssistantAgent()

requests = [
    "帮我分析这段代码有什么问题",
    "生成一个快速排序算法",
    "重构这段代码，提高可读性"
]

for req in requests:
    print(f"\n{'='*50}")
    print(f"用户请求: {req}")
    print(f"{'='*50}")
    response = assistant.process_request(req)
    print(response)
    print(f"{'='*50}")

6. 总结

用Yi-Coder-1.5B做智能体开发，给我的感觉是“刚刚好”。它没有大模型那么重的负担，但在代码理解和生成上的能力完全够用。特别是做技能集成和行为树设计时，小模型的快速响应和低资源消耗优势很明显。

从实际开发经验来看，有几个点比较重要：一是技能的定义要清晰，让模型能准确理解每个技能能做什么、需要什么参数；二是上下文管理要合理，128K虽然长，但也不能无限制地堆砌历史；三是缓存机制，对于重复的技能调用，缓存能显著提升效率。

当然，Yi-Coder-1.5B也不是万能的。对于特别复杂的逻辑推理，或者需要深度理解专业领域知识的情况，可能还是需要更大的模型。但对于大多数智能体应用场景——比如代码助手、自动化工具、信息处理代理——这个模型已经能做得相当不错了。

如果你也在做智能体开发，不妨试试这个小而强的模型。它的开源特性意味着你可以自由地调整和优化，而且社区资源也比较丰富。从简单的技能集成开始，逐步构建复杂的行为逻辑，你会发现开发智能体并没有想象中那么难。

---

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。