// extension.ts
import * as vscode from 'vscode';

export function activate(context: vscode.ExtensionContext) {
  // 启动 MCP 服务器
  const mcpServer = new MCPServer();
  mcpServer.start();
  
  // 注册命令处理 Copilot 请求
  context.subscriptions.push(
    vscode.commands.registerCommand('extension.queryCopilot', async (prompt) => {
      return await queryCopilotModel(prompt);
    })
  );
}

// mcp-server.ts
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

class MCPServer {
  private server: Server;
  
  constructor() {
    this.server = new Server({
      name: 'copilot-bridge',
      version: '1.0.0'
    }, {
      capabilities: {
        resources: {},
        tools: {},
        prompts: {}
      }
    });
    
    // 注册工具
    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
      tools: [{
        name: 'query_claude',
        description: 'Query Claude model via Copilot',
        inputSchema: { /* ... */ }
      }]
    }));
  }
  
  async start() {
    const transport = new StdioServerTransport();
    await this.server.connect(transport);
  }
}

// copilot-bridge.ts
async function queryCopilotModel(prompt: string) {
  // 获取 Copilot Chat API
  const copilot = await vscode.lm.selectChatModels({
    vendor: 'copilot',
    family: 'claude'
  });
  
  // 发送请求
  const messages = [
    vscode.LanguageModelChatMessage.User(prompt)
  ];
  
  const response = await copilot[0].sendRequest(messages);
  
  // 收集响应流
  let result = '';
  for await (const chunk of response.text) {
    result += chunk;
  }
  
  return result;
}

# external_agent.py
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def call_copilot_claude(prompt: str):
    # 连接到 VSCode 扩展的 MCP 服务器
    server_params = StdioServerParameters(
        command="code",
        args=["--extensionDevelopmentPath=/path/to/extension"]
    )
    
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            # 初始化连接
            await session.initialize()
            
            # 调用工具
            result = await session.call_tool("query_claude", {
                "prompt": prompt
            })
            
            return result

# 意图识别与工具调用示例
class IntentBasedAgent:
    def __init__(self, llm):
        self.llm = llm
        self.tools = {
            "weather": get_weather_tool,
            "email": send_email_tool,
            "database": query_database_tool,
            "calendar": schedule_meeting_tool
        }
    
    async def process(self, user_input: str):
        # 1. 意图识别（分类）
        intent_prompt = f"""
        分析用户意图，返回意图类别和参数：
        用户输入：{user_input}
        
        可选意图：weather, email, database, calendar
        返回 JSON 格式：{{"intent": "...", "params": {{...}}}}
        """
        
        response = await self.llm.query(intent_prompt)
        intent_data = json.loads(response)
        
        intent = intent_data["intent"]
        params = intent_data["params"]
        
        # 2. 根据意图调用相应工具
        if intent in self.tools:
            tool = self.tools[intent]
            result = await tool(**params)
            return result
        else:
            return "抱歉，我无法理解您的意图"

# 使用示例
agent = IntentBasedAgent(llm)

# 用户输入："查询明天北京的天气"
# 意图识别结果：intent="weather", params={"date": "明天", "city": "北京"}
# 调用工具：get_weather_tool(date="明天", city="北京")

# 使用 Function Calling / Tool Use
tools_schema = [
    {
        "name": "get_weather",
        "description": "查询天气信息",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "城市名称"},
                "date": {"type": "string", "description": "日期"}
            }
        }
    },
    {
        "name": "send_email",
        "description": "发送邮件",
        "parameters": {
            "type": "object",
            "properties": {
                "to": {"type": "string"},
                "subject": {"type": "string"},
                "body": {"type": "string"}
            }
        }
    }
]

# LLM 自动识别意图并返回应调用的工具
response = llm.chat(
    messages=[{"role": "user", "content": user_input}],
    tools=tools_schema
)

# LLM 返回：tool_call = {"name": "get_weather", "arguments": {"city": "北京", "date": "明天"}}

# 使用文本分类模型
from transformers import pipeline

classifier = pipeline("text-classification", model="intent-classifier")
result = classifier("查询明天北京的天气")
# 输出：{"label": "weather", "score": 0.95}

# 关键词匹配
intent_patterns = {
    "weather": ["天气", "温度", "下雨"],
    "email": ["发邮件", "发送邮件", "写邮件"],
    "database": ["查询", "数据", "统计"]
}

def match_intent(user_input):
    for intent, keywords in intent_patterns.items():
        if any(kw in user_input for kw in keywords):
            return intent
    return "unknown"

用户输入（自然语言） → Slot Filling → 结构化参数 → 工具调用

输入："查询明天北京的天气"
槽位提取：
  - intent: "get_weather"
  - city: "北京"
  - date: "明天"
  
工具调用：get_weather(city="北京", date="明天")

输入："查询明天的天气"
槽位提取：
  - intent: "get_weather"
  - city: null  # 必填槽位缺失
  - date: "明天"
  
Agent 追问："请问您要查询哪个城市的天气？"
用户回答："北京"
补充槽位：city: "北京"
工具调用：get_weather(city="北京", date="明天")

# 使用 LLM 自动提取槽位
slot_extraction_prompt = """
从用户输入中提取以下信息：
- 城市（city）
- 日期（date）
- 时间（time）

用户输入：{user_input}

返回 JSON 格式：{{"city": "...", "date": "...", "time": "..."}}
如果某个信息未提及，返回 null。
"""

# LLM 处理
user_input = "帮我查一下后天上海的天气"
response = llm.query(slot_extraction_prompt.format(user_input=user_input))
slots = json.loads(response)
# 结果：{"city": "上海", "date": "后天", "time": null}

# OpenAI Function Calling 示例
function_schema = {
    "name": "get_weather",
    "description": "查询天气信息",
    "parameters": {
        "type": "object",
        "properties": {
            "city": {
                "type": "string",
                "description": "城市名称"
            },
            "date": {
                "type": "string",
                "description": "日期，如'今天'、'明天'、'2025-11-20'"
            }
        },
        "required": ["city"]  # 必填槽位
    }
}

# LLM 自动提取并验证槽位
response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "明天北京会下雨吗"}],
    functions=[function_schema],
    function_call="auto"
)

# LLM 自动返回：
# {
#   "name": "get_weather",
#   "arguments": {
#     "city": "北京",
#     "date": "明天"
#   }
# }

# 使用 NER（命名实体识别）+ 规则
from transformers import pipeline

ner = pipeline("ner", model="bert-base-chinese-ner")
text = "查询明天北京的天气"
entities = ner(text)

# 输出：
# [
#   {"entity": "TIME", "word": "明天"},
#   {"entity": "LOC", "word": "北京"}
# ]

# 映射到槽位
slots = {
    "date": "明天",  # TIME → date
    "city": "北京"   # LOC → city
}

class SlotFillingAgent:
    def __init__(self):
        self.slots = {
            "city": None,
            "date": None
        }
        self.required_slots = ["city"]
    
    def process(self, user_input):
        # 提取槽位
        extracted = extract_slots(user_input)
        self.slots.update(extracted)
        
        # 检查必填槽位
        missing = [s for s in self.required_slots if not self.slots[s]]
        
        if missing:
            # 槽位缺失，追问
            return self.ask_for_slot(missing[0])
        else:
            # 槽位完整，执行工具调用
            return self.call_tool()
    
    def ask_for_slot(self, slot_name):
        questions = {
            "city": "请问您要查询哪个城市的天气？",
            "date": "请问您要查询哪天的天气？"
        }
        return questions.get(slot_name)
    
    def call_tool(self):
        return get_weather(**self.slots)

# 使用示例
agent = SlotFillingAgent()

# 第一轮
response1 = agent.process("查明天的天气")
print(response1)  # "请问您要查询哪个城市的天气？"

# 第二轮
response2 = agent.process("北京")
print(response2)  # 返回天气信息

def normalize_slots(slots):
    """标准化槽位值"""
    # 时间标准化
    if slots.get("date"):
        slots["date"] = normalize_date(slots["date"])
        # "明天" → "2025-11-20"
        # "后天" → "2025-11-21"
    
    # 地点标准化
    if slots.get("city"):
        slots["city"] = normalize_city(slots["city"])
        # "帝都" → "北京"
        # "魔都" → "上海"
    
    return slots

用户输入 → LLM 分析 → 返回函数调用指令 → 执行函数 → 返回结果 → LLM 生成自然语言响应

# 步骤1：意图识别
intent_prompt = "用户说：'明天北京会下雨吗'，意图是什么？返回：weather/email/calendar"
intent = llm.query(intent_prompt)  # 返回 "weather"

# 步骤2：参数提取
slot_prompt = "从'明天北京会下雨吗'中提取：城市、日期。返回JSON"
slots = json.loads(llm.query(slot_prompt))  # {"city": "北京", "date": "明天"}

# 步骤3：手动验证和调用
if intent == "weather":
    if "city" not in slots:
        return "请提供城市名称"
    result = get_weather(city=slots["city"], date=slots.get("date"))

# 一次性完成！
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "查询天气信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "城市名称"
                    },
                    "date": {
                        "type": "string",
                        "description": "日期",
                        "default": "今天"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "明天北京会下雨吗"}],
    tools=tools,
    tool_choice="auto"
)

# LLM 自动返回：
# {
#   "tool_calls": [{
#     "function": {
#       "name": "get_weather",
#       "arguments": '{"city": "北京", "date": "明天"}'
#     }
#   }]
# }

# 直接执行
tool_call = response.choices[0].message.tool_calls[0]
result = get_weather(**json.loads(tool_call.function.arguments))

# 用户："查询明天北京的天气，并给张三发邮件通知"
# LLM 自动识别需要调用两个函数
response = {
    "tool_calls": [
        {
            "function": {
                "name": "get_weather",
                "arguments": '{"city": "北京", "date": "明天"}'
            }
        },
        {
            "function": {
                "name": "send_email",
                "arguments": '{"to": "zhangsan@example.com", "subject": "天气通知"}'
            }
        }
    ]
}

# 用户："那里明天会下雨吗？"（上下文：之前提到北京）
# LLM 自动从对话历史推断参数
response = {
    "tool_calls": [{
        "function": {
            "name": "get_weather",
            "arguments": '{"city": "北京", "date": "明天"}'  # 自动推断 city
        }
    }]
}

# 用户："提醒我3小时后开会"
# LLM 自动将"3小时后"转换为正确的时间格式
response = {
    "tool_calls": [{
        "function": {
            "name": "set_reminder",
            "arguments": '{"time": "2025-11-19T11:30:00", "message": "开会"}'
        }
    }]
}

import openai
import json

# 定义可用的工具
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取指定城市的天气信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "城市名称"},
                    "date": {"type": "string", "description": "日期，默认今天"},
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "温度单位"
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_weather_forecast",
            "description": "获取未来多天的天气预报",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string"},
                    "days": {"type": "integer", "description": "预报天数"}
                },
                "required": ["city", "days"]
            }
        }
    }
]

# 实际的工具函数
def get_weather(city, date="今天", unit="celsius"):
    # 实际调用天气 API
    return f"{city}{date}的天气：晴，25°C"

def get_weather_forecast(city, days):
    return f"{city}未来{days}天天气预报：..."

# Agent 主循环
def run_agent(user_message):
    messages = [{"role": "user", "content": user_message}]
    
    # 第一次调用：LLM 决定调用什么函数
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=messages,
        tools=tools,
        tool_choice="auto"
    )
    
    response_message = response.choices[0].message
    
    # 如果 LLM 决定调用函数
    if response_message.tool_calls:
        # 执行函数调用
        for tool_call in response_message.tool_calls:
            function_name = tool_call.function.name
            function_args = json.loads(tool_call.function.arguments)
            
            # 调用实际函数
            if function_name == "get_weather":
                function_response = get_weather(**function_args)
            elif function_name == "get_weather_forecast":
                function_response = get_weather_forecast(**function_args)
            
            # 将函数结果添加到对话
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": function_response
            })
        
        # 第二次调用：让 LLM 基于函数结果生成自然语言回复
        final_response = openai.ChatCompletion.create(
            model="gpt-4",
            messages=messages
        )
        
        return final_response.choices[0].message.content
    
    # 如果不需要调用函数，直接返回
    return response_message.content

# 测试
print(run_agent("明天北京会下雨吗？"))
# LLM 自动：1. 识别需要调用 get_weather
#          2. 提取参数 city="北京", date="明天"
#          3. 执行函数
#          4. 生成自然语言回复："根据查询，明天北京是晴天，不会下雨。"

问：小明有 5 个苹果，给了小红 2 个，又买了 3 个，现在有几个？
答：6 个

问：小明有 5 个苹果，给了小红 2 个，又买了 3 个，现在有几个？
答：
  步骤 1：小明初始有 5 个苹果
  步骤 2：给了小红 2 个，剩下 5 - 2 = 3 个
  步骤 3：又买了 3 个，现在有 3 + 3 = 6 个
  最终答案：6 个

def ask_with_cot(question: str) -> str:
    prompt = f"""
{question}

让我们一步一步地思考：
"""
    return llm.call(prompt)

system_prompt = """
你是一个情感分析助手。

输出要求：
- 只输出 JSON，不要有任何额外文字
- 格式如下：
{
  "sentiment": "positive" | "negative" | "neutral",
  "confidence": 0.0 ~ 1.0,
  "reason": "简短理由（不超过 20 字）"
}
"""

response = llm.call(system_prompt, user_input="这个产品真的太好用了！")
# 输出：{"sentiment": "positive", "confidence": 0.95, "reason": "用户使用了强烈的赞美语气"}

from openai import OpenAI
from pydantic import BaseModel

class SentimentResult(BaseModel):
    sentiment: Literal["positive", "negative", "neutral"]
    confidence: float
    reason: str

client = OpenAI()
response = client.beta.chat.completions.parse(
    model="gpt-4o",
    messages=[{"role": "user", "content": "这个产品真的太好用了！"}],
    response_format=SentimentResult,
)

result = response.choices[0].message.parsed
print(result.sentiment)    # positive
print(result.confidence)   # 0.95

import outlines

model = outlines.models.transformers("mistralai/Mistral-7B-v0.1")

# 定义 Schema
schema = """{
  "type": "object",
  "properties": {
    "sentiment": {"type": "string", "enum": ["positive", "negative", "neutral"]},
    "confidence": {"type": "number"},
    "reason": {"type": "string"}
  },
  "required": ["sentiment", "confidence", "reason"]
}"""

generator = outlines.generate.json(model, schema)
result = generator("这个产品真的太好用了！")
# result 是一个合法的 Python dict，不可能格式错误

import json
import re

def parse_with_retry(prompt: str, max_retries: int = 3) -> dict:
    for attempt in range(max_retries):
        raw = llm.call(prompt)
        try:
            # 尝试提取 JSON 块
            match = re.search(r'\{.*\}', raw, re.DOTALL)
            if match:
                return json.loads(match.group())
        except json.JSONDecodeError:
            if attempt < max_retries - 1:
                # 追加修正提示，让模型重新生成
                prompt += f"\n\n上次输出格式有误：{raw}\n请严格按 JSON 格式重新输出，不要添加任何解释文字。"
    raise ValueError(f"连续 {max_retries} 次解析失败")

用户输入 → LLM 推理(Thought) → 决定行动(Action) → 执行工具 → 观察结果(Observation) → 继续推理 → ...

react_prompt_template = """
你是一个智能助手，可以使用以下工具：
1. search(query): 搜索信息
2. calculate(expression): 计算数学表达式
3. get_weather(city): 查询天气

请按以下格式回答：
Thought: [你的思考过程]
Action: [工具名称]
Action Input: [工具参数]
Observation: [工具返回的结果]
... (重复 Thought/Action/Observation 直到得出答案)
Answer: [最终答案]

问题：{question}
"""

# 用户问题："北京明天的天气适合户外活动吗？"

# LLM 输出：
"""
Thought: 我需要先查询北京明天的天气
Action: get_weather
Action Input: {"city": "北京", "date": "明天"}
Observation: 明天北京天气：晴，温度 22°C，微风

Thought: 根据天气信息，晴天、温度适中、微风，非常适合户外活动
Answer: 根据天气预报，北京明天天气晴朗，温度 22°C，微风，非常适合户外活动。
"""

tool_selection_prompt = """
根据用户输入，选择合适的工具并提取参数。

可用工具：
- get_weather: 查询天气，参数: city, date
- send_email: 发送邮件，参数: to, subject, body
- search: 搜索信息，参数: query

用户输入：{user_input}

请以 JSON 格式返回：
{
  "tool": "工具名称",
  "parameters": {
    "参数名": "参数值"
  }
}
"""

# 用户："查询明天上海的天气"
# LLM 返回：
{
  "tool": "get_weather",
  "parameters": {
    "city": "上海",
    "date": "明天"
  }
}

from langchain.agents import Tool, AgentExecutor, create_react_agent
from langchain.tools import BaseTool

# 定义工具
class WeatherTool(BaseTool):
    name = "get_weather"
    description = "获取指定城市的天气信息。输入：城市名称"
    
    def _run(self, city: str) -> str:
        return f"{city}的天气：晴朗"

class EmailTool(BaseTool):
    name = "send_email"
    description = "发送邮件。输入：收件人,主题,正文"
    
    def _run(self, to: str, subject: str, body: str) -> str:
        return f"已发送邮件给 {to}"

# 创建 Agent
tools = [WeatherTool(), EmailTool()]
agent = create_react_agent(llm, tools, prompt_template)
agent_executor = AgentExecutor(agent=agent, tools=tools)

# 执行
result = agent_executor.run("查询北京的天气并发邮件通知张三")

from sentence_transformers import SentenceTransformer
import numpy as np

# 1. 工具库（包含描述）
tools_library = [
    {"name": "get_weather", "description": "查询城市天气信息"},
    {"name": "send_email", "description": "发送电子邮件"},
    {"name": "search_web", "description": "在网络上搜索信息"},
    {"name": "calculate", "description": "计算数学表达式"},
    # ... 100+ 个工具
]

# 2. 向量化工具描述
model = SentenceTransformer('all-MiniLM-L6-v2')
tool_embeddings = model.encode([t["description"] for t in tools_library])

# 3. 检索相关工具
def retrieve_tools(user_query, top_k=3):
    query_embedding = model.encode([user_query])
    similarities = np.dot(query_embedding, tool_embeddings.T)[0]
    top_indices = np.argsort(similarities)[-top_k:][::-1]
    return [tools_library[i] for i in top_indices]

# 4. 让 LLM 从候选工具中选择
user_query = "明天北京会下雨吗？"
candidate_tools = retrieve_tools(user_query)  # 返回：get_weather, search_web

# 5. LLM 从候选中选择
function_calling_with_candidates(user_query, candidate_tools)

code_gen_prompt = """
你有以下 Python 函数可用：
- get_weather(city, date)
- send_email(to, subject, body)
- calculate(expression)

根据用户需求，生成 Python 代码来完成任务。

用户：查询明天北京的天气
代码：
```python
result = get_weather("北京", "明天")
print(result)

weather = get_weather("上海", "明天")
send_email("user@example.com", "天气通知", f"明天上海天气：{weather}")

#### 优势
- **灵活性极高**：可以实现复杂的逻辑组合
- **无需预定义**：不需要严格的工具 schema
- **支持组合**：可以组合多个工具调用

#### 劣势
- **安全风险**：执行生成的代码有安全隐患
- **难以控制**：生成的代码可能不符合预期
- **调试困难**：代码错误难以追踪

### 6. Fine-tuned Model（微调模型）

专门训练一个小模型用于意图识别和参数提取。

#### 实现流程

```python
# 1. 准备训练数据
training_data = [
    {
        "input": "查询明天北京的天气",
        "output": {
            "intent": "get_weather",
            "params": {"city": "北京", "date": "明天"}
        }
    },
    # ... 数千条标注数据
]

# 2. 微调模型
from transformers import AutoModelForSequenceClassification, Trainer

model = AutoModelForSequenceClassification.from_pretrained("bert-base-chinese")
trainer = Trainer(model=model, train_dataset=training_data)
trainer.train()

# 3. 推理
def predict_intent_and_params(text):
    result = model(text)
    return result  # {"intent": "...", "params": {...}}

# 示例：Tool Retrieval + Function Calling
def hybrid_agent(user_input):
    # 1. 工具检索：从 100+ 工具中筛选出 5 个候选
    candidate_tools = retrieve_tools(user_input, top_k=5)
    
    # 2. Function Calling：从候选中精确选择
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "user", "content": user_input}],
        tools=candidate_tools,  # 只传入候选工具
        tool_choice="auto"
    )
    
    return response

用户应用
   ↓
[LangChain/LlamaIndex 框架] ← 可选
   ↓
[Function Calling API] ← 核心
   ↓
[LLM (GPT-4/Claude)]

# 未来主流架构
def next_gen_agent(user_query, tool_library_size=1000+):
    # 第一层：语义检索（快速筛选）
    candidates = vector_search(user_query, top_k=5)
    
    # 第二层：Function Calling（精确选择）
    tool_call = llm.function_call(user_query, tools=candidates)
    
    # 第三层：执行和反馈
    result = execute_tool(tool_call)
    return result

# 未来示例：图像 + 文本 → 工具调用
response = llm.function_call(
    messages=[
        {"role": "user", "content": [
            {"type": "text", "text": "这张图片中的产品多少钱？"},
            {"type": "image_url", "image_url": "..."}
        ]}
    ],
    tools=[
        {"name": "product_search", ...},
        {"name": "price_lookup", ...}
    ]
)
# LLM 识别图片内容并调用价格查询工具

用户查询 → 协调 Agent → 拆解任务 → 并行调度专业 Agent → 结果汇总
           (Function Calling)  ↓         ↓
                          [数据分析 Agent]  [报告生成 Agent]
                          [信息检索 Agent]  [代码执行 Agent]

方案：Function Calling (OpenAI/Claude/Gemini)
原因：稳定、可靠、开发效率高、持续优化
成本：中等（API 调用费用）

方案：Tool Retrieval + Function Calling
原因：支持大量内部工具，可扩展性好
成本：中等

方案：LangChain + Function Calling
原因：快速开发，丰富的组件
成本：低（快速迭代）

方案：Fine-tuned Model 或 本地 Llama + Function Calling
原因：低延迟，无需网络，成本可控
成本：高（训练和部署）

方案：ReAct + Function Calling
原因：可解释性强，适合多步推理
成本：高（多次 LLM 调用）

from langchain.llms import OpenAI, Anthropic, HuggingFaceHub
from langchain.chat_models import ChatOpenAI, ChatAnthropic

# OpenAI
llm = OpenAI(temperature=0.7)

# Claude
chat = ChatAnthropic(model="claude-3-sonnet-20240229")

# 本地模型
from langchain.llms import Ollama
local_llm = Ollama(model="llama2")

from langchain.prompts import PromptTemplate, ChatPromptTemplate

# 简单模板
prompt = PromptTemplate(
    input_variables=["product"],
    template="给{product}写一个广告语"
)

# 聊天模板
chat_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个{role}"),
    ("human", "{user_input}")
])

# 使用
formatted = prompt.format(product="智能手表")
result = llm(formatted)

from langchain.chains import LLMChain, SimpleSequentialChain

# 单个链
chain = LLMChain(llm=llm, prompt=prompt)
result = chain.run(product="智能手表")

# 顺序链
chain1 = LLMChain(llm=llm, prompt=prompt1)  # 生成产品描述
chain2 = LLMChain(llm=llm, prompt=prompt2)  # 生成广告语

overall_chain = SimpleSequentialChain(
    chains=[chain1, chain2],
    verbose=True
)
result = overall_chain.run("智能手表")

from langchain.agents import initialize_agent, Tool, AgentType
from langchain.tools import BaseTool

# 定义工具
class WeatherTool(BaseTool):
    name = "Weather"
    description = "查询天气信息。输入：城市名称"
    
    def _run(self, city: str) -> str:
        return f"{city}的天气：晴朗，25°C"
    
    async def _arun(self, city: str) -> str:
        return self._run(city)

# 创建 Agent
tools = [WeatherTool()]
agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

# 执行
result = agent.run("北京明天会下雨吗？")

from langchain.memory import ConversationBufferMemory, ConversationSummaryMemory
from langchain.chains import ConversationChain

# 完整历史记忆
memory = ConversationBufferMemory()

# 摘要记忆（节省 Token）
summary_memory = ConversationSummaryMemory(llm=llm)

# 对话链
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

# 多轮对话
conversation.predict(input="我叫张三")
conversation.predict(input="我的名字是什么？")  # 回答：张三

from langchain.document_loaders import (
    TextLoader, PDFLoader, CSVLoader,
    UnstructuredHTMLLoader, GitbookLoader
)

# PDF 文档
loader = PDFLoader("document.pdf")
documents = loader.load()

# 网页
from langchain.document_loaders import WebBaseLoader
loader = WebBaseLoader("https://example.com")
documents = loader.load()

from langchain.vectorstores import Chroma, FAISS, Pinecone
from langchain.embeddings import OpenAIEmbeddings

# 创建向量存储
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(
    documents=documents,
    embedding=embeddings
)

# 相似度检索
results = vectorstore.similarity_search("查询文本", k=3)

# RAG 链
from langchain.chains import RetrievalQA

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever()
)

answer = qa_chain.run("用户问题")

agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

memory = ConversationBufferMemory(memory_key="chat_history")

agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
    memory=memory,
    verbose=True
)

agent = initialize_agent(
    tools=tools,
    llm=ChatOpenAI(model="gpt-4"),
    agent=AgentType.OPENAI_FUNCTIONS,
    verbose=True
)

agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

from langchain.chat_models import ChatOpenAI
from langchain.document_loaders import DirectoryLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate

# 1. 加载文档
loader = DirectoryLoader(
    "./docs",
    glob="**/*.txt",
    loader_cls=TextLoader
)
documents = loader.load()

# 2. 切分文档
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
splits = text_splitter.split_documents(documents)

# 3. 创建向量存储
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(
    documents=splits,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

# 4. 定义提示模板
prompt_template = """
基于以下上下文回答问题。如果不知道答案，就说不知道，不要编造答案。

上下文：{context}

问题：{question}

答案：
"""

PROMPT = PromptTemplate(
    template=prompt_template,
    input_variables=["context", "question"]
)

# 5. 创建 QA 链
llm = ChatOpenAI(model="gpt-4", temperature=0)
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3}),
    return_source_documents=True,
    chain_type_kwargs={"prompt": PROMPT}
)

# 6. 使用
query = "LangChain 是什么？"
result = qa_chain({"query": query})

print(result["result"])
print("\n来源文档：")
for doc in result["source_documents"]:
    print(f"- {doc.metadata['source']}")

from langchain.schema.runnable import RunnablePassthrough
from langchain.schema.output_parser import StrOutputParser

# 使用 LCEL 构建链
chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

# 执行
result = chain.invoke("LangChain 是什么？")

# 流式输出
for chunk in chain.stream("LangChain 是什么？"):
    print(chunk, end="", flush=True)

# 批量处理
results = chain.batch([
    "问题1",
    "问题2",
    "问题3"
])

# 异步执行
result = await chain.ainvoke("问题")

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated

# 定义状态
class AgentState(TypedDict):
    messages: list
    next: str

# 定义节点
def call_model(state):
    response = llm.invoke(state["messages"])
    return {"messages": state["messages"] + [response]}

def should_continue(state):
    last_message = state["messages"][-1]
    if "FINAL ANSWER" in last_message.content:
        return "end"
    return "continue"

# 构建图
workflow = StateGraph(AgentState)
workflow.add_node("agent", call_model)
workflow.add_node("tools", call_tools)

workflow.set_entry_point("agent")
workflow.add_conditional_edges(
    "agent",
    should_continue,
    {
        "continue": "tools",
        "end": END
    }
)
workflow.add_edge("tools", "agent")

app = workflow.compile()

# 执行
result = app.invoke({"messages": [HumanMessage(content="查询天气")]})

# 使用 LangChain 做 RAG
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings

# RAG 部分使用 LangChain
vectorstore = Chroma.from_documents(documents, OpenAIEmbeddings())
retriever = vectorstore.as_retriever()

# 工具调用使用原生 Function Calling
tools_schema = [
    {
        "type": "function",
        "function": {
            "name": "search_knowledge_base",
            "description": "在知识库中搜索信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"}
                }
            }
        }
    }
]

def search_knowledge_base(query: str):
    # 使用 LangChain 的检索器
    docs = retriever.get_relevant_documents(query)
    return "\n".join([doc.page_content for doc in docs])

# Agent 主循环使用原生 API
response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=messages,
    tools=tools_schema
)

# 结合两者优势：LangChain 处理复杂数据，Function Calling 做工具调用