1
# 需要多个步骤
2
from langchain_openai import ChatOpenAI
3
from langchain.agents import AgentExecutor, create_react_agent
4
from langchain_core.prompts import PromptTemplate
5

6
# 1. 模型初始化
7
model = ChatOpenAI(model="gpt-4o-mini")
8

9
# 2. 创建提示词模板
10
prompt = PromptTemplate.from_template("""
11
You are a helpful assistant.
12
Tools: {tools}
13
Tool Names: {tool_names}
14
{agent_scratchpad}
15
""")
16

17
# 3. 创建 agent
18
agent = create_react_agent(
19
    llm=model,
20
    tools=tools,
21
    prompt=prompt
22
)
23

24
# 4. 创建 executor
25
executor = AgentExecutor(
26
    agent=agent,
27
    tools=tools,
28
    verbose=True
29
)
30

31
# 5. 调用
32
result = executor.invoke({"input": "问题"})

1
from langchain.chat_models import init_chat_model
2
from langchain.agents import create_agent
3

4
# 1. 初始化模型
5
model = init_chat_model("gpt-4o-mini", model_provider="openai")
6

7
# 2. 创建 agent（一步完成）
8
agent = create_agent(
9
    model=model,
10
    tools=[tool1, tool2],
11
    system_prompt="Agent 的行为指令"  # 可选
12
)
13

14
# 3. 调用
15
result = agent.invoke({
16
    "messages": [{"role": "user", "content": "问题"}]
17
})

1
from pydantic import BaseModel, Field
2
from langchain.agents import create_agent
3
from langchain.agents.structured_output import ProviderStrategy
4
from langchain.messages import HumanMessage
5
from rich import print as rprint
6
from langchain.chat_models import init_chat_model
7
from dotenv import load_dotenv
8
import os
9

10
load_dotenv(override=True)
11

12
# 1.模型初始化
13
model = init_chat_model(
14
    model="gpt-5.4-mini",
15
    model_provider="openai",
16
    api_key=os.getenv("CLOSEAI_API_KEY"),
17
    base_url=os.getenv("CLOSEAI_BASE_URL")
18
)
19

20
# 2.Pydantic结构化方式定义
21
class ContactInfo(BaseModel):
22
    """用户的联系方式"""
23
    name: str = Field(description="用户姓名")
24
    email: str = Field(description="用户邮箱地址")
25
    phone: str = Field(description="用户的手机号")
26

27
# 3.agent初始化
28
agent = create_agent(
29
    model=model,
30
    response_format=ProviderStrategy(ContactInfo)
31
)
32

33
# 4.调用
34
response = agent.invoke({
35
    "messages": [
36
        HumanMessage("从这段话中抽取结构化信息：小明的邮箱地址为：shkstart@atguigu.com，手机号：12345678912")
37
    ]
38
})
39
# rprint(response)
40
for msg in response["messages"]:
41
    msg.pretty_print()

1
================================= Human Message =================================
2
从这段话中抽取结构化信息：小明的邮箱地址为：shkstart@atguigu.com，手机号：12345678912
3
================================== Ai Message ==================================
4
{"name":"小明","email":"shkstart@atguigu.com","phone":"12345678912"}

1
from pydantic import BaseModel
2
from langchain.agents import create_agent
3
from langchain.agents.structured_output import ToolStrategy
4
from langchain.chat_models import init_chat_model
5
from dotenv import load_dotenv
6
import os
7

8
load_dotenv(override=True)
9

10
# 1.模型初始化
11
model = init_chat_model(
12
    model="gpt-5.4-mini",
13
    model_provider="openai",
14
    api_key=os.getenv("CLOSEAI_API_KEY"),
15
    base_url=os.getenv("CLOSEAI_BASE_URL")
16
)
17

18
# 2.Pydantic结构化方式定义
19
class ContactInfo(BaseModel):
20
    name: str = Field(description="姓名")
21
    email: str = Field(description="邮箱")
22
    phone: str = Field(description="电话")
23

24
# 3.工具的定义（根据需要定义）
25
@tool
26
def search_tool(query: str) -> str:
27
    """这是一个搜索引擎。当大模型发现给定的上下文里缺少必要的联系人信息，需要去互联网上查询时，才会调用这个工具。
28
    """
29
    return f"搜索结果: 未找到关于 '{query}' 的更多额外信息。"
30

31
# 3.agent初始化
32
agent = create_agent(
33
    model=model,
34
    tools=[search_tool],
35
    response_format=ToolStrategy(ContactInfo)
36
)
37

38
result = agent.invoke({
39
    "messages": [{"role": "user", "content": "联系人信息: John Doe, john@atguigu.com, (010) 56253825"}]
40
})
41
# print(result)
42
print(result["structured_response"])

1
name='John Doe' email='john@atguigu.com' phone='(010) 56253825'

1
ResponseFormat = ToolStrategy[SchemaT] | ProviderStrategy[SchemaT] | AutoStrategy[SchemaT]
2
"""Union type for all supported response format strategies."""

1
from langchain.agents.structured_output import AutoStrategy
2
from pydantic import BaseModel, Field
3
from langchain.agents import create_agent
4

5
class ContactInfo(BaseModel):
6
    """联系人信息"""
7
    name: str = Field(description="姓名")
8
    email: str = Field(description="邮箱")
9
    phone: str = Field(description="电话")
10

11
agent = create_agent(
12
    model=model,
13
    response_format=AutoStrategy(ContactInfo)
14
)
15

16
result = agent.invoke({
17
    "messages": [{"role": "user", "content": "联系人信息: John Doe, john@atguigu.com, (010) 56253825"}]
18
})
19
# print(result)
20
print(result["structured_response"])

1
name='John Doe' email='john@atguigu.com' phone='(010) 56253825'

1
from pydantic import BaseModel, Field
2
from langchain.agents import create_agent
3

4
class ContactInfo(BaseModel):
5
    """联系人信息"""
6
    name: str = Field(description="姓名")
7
    email: str = Field(description="邮箱")
8
    phone: str = Field(description="电话")
9

10
agent = create_agent(
11
    model=model,
12
    response_format=ContactInfo  # Auto-selects ProviderStrategy
13
)
14

15
result = agent.invoke({
16
    "messages": [{"role": "user", "content": "联系人信息: John Doe, john@atguigu.com, (010) 56253825"}]
17
})
18
# print(result)
19
print(result["structured_response"])

1
name='John Doe' email='john@atguigu.com' phone='(010) 56253825'

1
from langchain.chat_models import init_chat_model
2
from dotenv import load_dotenv
3
import os
4

5
# 从.env文件中加载环境变量
6
load_dotenv(override=True)
7

8
CLOSEAI_API_KEY = os.getenv("CLOSEAI_API_KEY")
9
CLOSEAI_BASE_URL = os.getenv("CLOSEAI_BASE_URL")
10

11
model = init_chat_model(
12
    model="gpt-5.4-mini",
13
    model_provider="openai",
14
    api_key=CLOSEAI_API_KEY,
15
    base_url=CLOSEAI_BASE_URL
16
)

1
from langchain_openrouter import ChatOpenRouter
2
from dotenv import load_dotenv
3
import os
4

5
load_dotenv(override=True)
6

7
OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
8
OPENROUTER_API_BASE = os.getenv("OPENROUTER_API_BASE")
9

10
model = ChatOpenRouter(
11
    model="openai/gpt-5.4-mini",
12
    api_key=OPENROUTER_API_KEY,
13
    base_url=OPENROUTER_API_BASE,
14
)

1
from pydantic import BaseModel, Field
2
from langchain.agents.structured_output import ToolStrategy
3
from langchain.agents import create_agent
4
from langchain.messages import HumanMessage
5

6
class ContactInfo(BaseModel):
7
    """用户的联系方式"""
8
    name: str = Field(description="用户姓名")
9
    email: str = Field(description="用户邮箱地址")
10
    phone: str = Field(description="用户的手机号")
11

12
agent = create_agent(
13
    model=model,
14
    response_format=ToolStrategy(ContactInfo)
15
)
16

17
response = agent.invoke({
18
    "messages": [
19
        HumanMessage("从这段话中抽取结构化信息：小明的邮箱地址为：songhk@atguigu.com，手机号：12345678912")
20
    ]
21
})
22
for msg in response["messages"]:
23
    msg.pretty_print()
24
# print(response["structured_response"])

1
================================= Human Message =================================
2
从这段话中抽取结构化信息：小明的邮箱地址为：songhk@atguigu.com，手机号：12345678912
3
================================== Ai Message ==================================
4
Tool Calls:
5
  ContactInfo (call_0ULr5y5MWny1wAgv2JXLDDyO)
6
  Args:
7
    name: 小明
8
    email: songhk@atguigu.com
9
    phone: 12345678912
10
================================= Tool Message =================================
11
Name: ContactInfo
12
Returning structured response: name='小明' email='songhk@atguigu.com' phone='12345678912'

1
from langchain_core.messages import SystemMessage
2
from pydantic import BaseModel, Field
3
from typing import Literal
4
from langchain.agents import create_agent
5
from langchain.agents.structured_output import ToolStrategy
6
from langchain.tools import tool
7
from rich import print as rprint
8

9
# 定义工具
10
@tool(parse_docstring=True)
11
def search_customer_database(query: str) -> str:
12
    """
13
    在客户数据库中搜索信息
14
    Args:
15
        query (str): 客户查询字符串，例如 "张三" 或 "李四"
16
    Returns:
17
        str: 客户记录字符串，包含客户姓名、等级、最近购买日期和累计消费
18
    """
19
    # 模拟数据库查询结果
20
    if "张三" in query.lower():
21
        return "客户记录：张三，VIP客户，最近购买日期：2026-01-15，累计消费：$15,000"
22
    elif "李四" in query.lower():
23
        return "客户记录：李四，普通客户，最近购买日期：2025-12-20，累计消费：$3,200"
24
    else:
25
        return f"关于客户{query}，无记录"
26

27
@tool(parse_docstring=True)
28
def send_email(customer: str) -> str:
29
    """
30
    发送感谢邮件
31
    Args:
32
        customer (str): 客户名称，例如 "张三" 或 "李四"
33
    Returns:
34
        str: 确认消息，包含已发送的客户名称
35
    """
36
    return f"已向 {customer} 发送感谢邮件"
37

38
# 定义Pydantic Schema
39
class CustomerAnalysis(BaseModel):
40
    """客户分析报告"""
41
    customer_name: str = Field(None, description="客户姓名")
42
    customer_tier: Literal["潜在客户", "普通客户", "VIP客户", "流失风险"] = Field("潜在客户", description="客户等级,只能是潜在客户、普通客户、VIP客户或流失风险")
43
    recent_activity: str = Field(None, description="最近活动")
44
    spending_level: Literal["低", "中", "高"] = Field(None, description="消费水平")
45
    send_email: bool = Field(False, description="是否已发送感谢邮件")
46

47
# 创建智能体
48
agent = create_agent(
49
    model=model,
50
    system_prompt=SystemMessage(content=""
51
        "请分析指定客户的情况："
52
        "1. 先搜索客户数据库了解最新情况 "
53
        "2. 如果是VIP客户，则发送感谢邮件 "
54
        "3. 基于搜索结果生成结构化分析报告 "
55
        "4. 如果用户提问与客户记录无关或找不到客户信息，则返回空对象，不发送感谢邮件"
56
    ),
57
    tools=[search_customer_database, send_email],
58
    response_format=ToolStrategy(CustomerAnalysis)
59
)
60

61
# 执行分析
62
result = agent.invoke({
63
    "messages": [{"role": "user", "content": "请分析客户张三"}]
64
    # "messages": [{"role": "user","content": "请分析客户李四"}]
65
    # "messages": [{"role": "user","content": "请分析客户王五"}]
66
    # "messages": [{"role": "user","content": "今天天气如何"}]
67
})
68
# 处理结果
69
# rprint(result)
70
if "structured_response" in result:
71
    analysis = result["structured_response"]
72
    print(analysis)

1
customer_name='张三' customer_tier='VIP客户' recent_activity='最近购买日期：2026-01-15' spending_level='高' send_email=True

1
from typing import TypedDict, Annotated
2
from langchain.agents.structured_output import ToolStrategy
3
from langchain.agents import create_agent
4
from langchain.messages import HumanMessage
5

6
class ContactInfo(TypedDict):
7
    """用户的联系方式"""
8
    name: Annotated[str, ..., "用户姓名"]
9
    email: Annotated[str, ..., "用户邮箱地址"]
10
    phone: Annotated[str, ..., "用户的手机号"]
11

12
agent = create_agent(
13
    model=model,
14
    response_format=ToolStrategy(ContactInfo)
15
)
16

17
response = agent.invoke({
18
    "messages": [
19
        HumanMessage("从这段话中抽取结构化信息：小明的邮箱地址为：songhk@atguigu.com，手机号：12345678912")
20
    ]
21
})
22
for msg in response["messages"]:
23
    msg.pretty_print()
24
# print(response["structured_response"])

1
================================= Human Message =================================
2
从这段话中抽取结构化信息：小明的邮箱地址为：songhk@atguigu.com，手机号：12345678912
3
================================== Ai Message ==================================
4
Tool Calls:
5
  ContactInfo (call_cyte01flJ8pJnPcsq7Gkb5V7)
6
  Args:
7
    name: 小明
8
    email: songhk@atguigu.com
9
    phone: 12345678912
10
================================= Tool Message =================================
11
Name: ContactInfo
12
Returning structured response: {'name': '小明', 'email': 'songhk@atguigu.com', 'phone': '12345678912'}

1
from langchain_core.messages import SystemMessage
2
from typing import Literal, Optional
3
from langchain.agents import create_agent
4
from langchain.agents.structured_output import ToolStrategy
5
from langchain.tools import tool
6

7
# 定义工具
8
@tool(parse_docstring=True)
9
def search_customer_database(query: str) -> str:
10
    """
11
    在客户数据库中搜索信息
12
    Args:
13
        query (str): 客户查询字符串，例如 "张三" 或 "李四"
14
    Returns:
15
        str: 客户记录字符串，包含客户姓名、等级、最近购买日期和累计消费
16
    """
17
    # 模拟数据库查询结果
18
    if "张三" in query.lower():
19
        return "客户记录：张三，VIP客户，最近购买日期：2026-01-15，累计消费：$15,000"
20
    elif "李四" in query.lower():
21
        return "客户记录：李四，普通客户，最近购买日期：2025-12-20，累计消费：$3,200"
22
    else:
23
        return f"关于客户{query}，无记录"
24

25
@tool(parse_docstring=True)
26
def send_email(customer: str) -> str:
27
    """
28
    发送感谢邮件
29
    Args:
30
        customer (str): 客户名称，例如 "张三" 或 "李四"
31
    Returns:
32
        str: 确认消息，包含已发送的客户名称
33
    """
34
    return f"已向 {customer} 发送感谢邮件"
35

36
# 使用 TypedDict 定义客户分析报告 Schema
37
class CustomerAnalysis(TypedDict):
38
    """客户分析报告"""
39
    customer_name: Annotated[Optional[str], None, "客户姓名"]
40
    customer_tier: Annotated[Literal["潜在客户", "普通客户", "VIP客户", "流失风险"], "潜在客户", "客户等级"]
41
    recent_activity: Annotated[Optional[str], None, "最近活动"]
42
    spending_level: Annotated[Optional[Literal["低", "中", "高"]], None, "消费水平"]
43
    send_email: Annotated[bool, False, "是否已发送感谢邮件"]
44

45
# 创建智能体
46
agent = create_agent(
47
    model=model,
48
    system_prompt=SystemMessage(content=""
49
        "请分析指定客户的情况："
50
        "1. 先搜索客户数据库了解最新情况 "
51
        "2. 如果是VIP客户，则发送感谢邮件 "
52
        "3. 基于搜索结果生成结构化分析报告 "
53
        "4. 如果用户提问与客户记录无关或找不到客户信息，则返回空对象，不发送感谢邮件"
54
    ),
55
    tools=[search_customer_database, send_email],
56
    response_format=ToolStrategy(CustomerAnalysis)
57
)
58

59
# 执行分析
60
result = agent.invoke({
61
    "messages": [{"role": "user", "content": "请分析客户张三"}]
62
    # "messages": [{"role": "user","content": "请分析客户李四"}]
63
    # "messages": [{"role": "user","content": "请分析客户王五"}]
64
    # "messages": [{"role": "user","content": "今天天气如何"}]
65
})
66
# 处理结果
67
# print("result:", result)
68
if "structured_response" in result:
69
    analysis = result["structured_response"]
70
    print(analysis)

1
{'customer_name': '张三', 'customer_tier': 'VIP客户', 'recent_activity': '最近购买日期：2026-01-15，累计消费：$15,000', 'spending_level': '高', 'send_email': True}

1
from langchain.agents import create_agent
2
from langchain.messages import HumanMessage
3

4
json_schema = {
5
    "title": "ContactInfo",
6
    "description": "用户的联系方式",
7
    "type": "object",
8
    "properties": {
9
        "name": {
10
            "description": "用户姓名",
11
            "type": "string"
12
        },
13
        "email": {
14
            "description": "用户邮箱地址",
15
            "type": "string"
16
        },
17
        "phone": {
18
            "description": "用户的手机号",
19
            "type": "string"
20
        }
21
    },
22
    "required": [
23
        "name",
24
        "email",
25
        "phone"
26
    ]
27
}
28

29
agent = create_agent(
30
    model=model,
31
    response_format=ToolStrategy(json_schema)
32
)
33

34
response = agent.invoke(
35
    {
36
        "messages": [
37
            HumanMessage("从这段话中抽取结构化信息：小明的邮箱地址为：songhk@atguigu.com，手机号：12345678912")
38
        ]
39
    }
40
)
41
for msg in response["messages"]:
42
    msg.pretty_print()
43
# print(response["structured_response"])