aiofiles==25.1.0
aiohappyeyeballs==2.6.1
aiohttp==3.13.3
aiosignal==1.4.0
annotated-types==0.7.0
anthropic==0.75.0
anyio==4.12.0
asttokens==3.0.1
attrs==25.4.0
backoff==2.2.1
beautifulsoup4==4.14.3
bracex==2.6
certifi==2026.1.4
cffi==2.0.0
charset-normalizer==3.4.4
click==8.3.1
colorama==0.4.6
comm==0.2.3
cryptography==46.0.3
dataclasses-json==0.6.7
debugpy==1.8.19
decorator==5.2.1
deepagents==0.3.5
distro==1.9.0
docstring_parser==0.17.0
docx==0.2.4
emoji==2.15.0
executing==2.2.1
filelock==3.20.3
filetype==1.2.0
frozenlist==1.8.0
fsspec==2026.1.0
google-auth==2.47.0
google-genai==1.57.0
greenlet==3.3.0
grpcio==1.76.0
h11==0.16.0
html5lib==1.1
httpcore==1.0.9
httpx==0.28.1
httpx-sse==0.4.3
huggingface-hub==0.36.0
idna==3.11
ipykernel==7.1.0
ipython==9.9.0
ipython_pygments_lexers==1.1.1
jedi==0.19.2
Jinja2==3.1.6
jiter==0.12.0
joblib==1.5.3
jsonpatch==1.33
jsonpointer==3.0.0
jsonschema==4.26.0
jsonschema-specifications==2025.9.1
jupyter_client==8.8.0
jupyter_core==5.9.1
langchain==1.2.3
langchain-anthropic==1.3.1
langchain-classic==1.0.1
langchain-community==0.4.1
langchain-core==1.2.6
langchain-deepseek==1.0.1
langchain-google-genai==4.1.3
langchain-huggingface==1.2.0
langchain-mcp-adapters==0.2.1
langchain-openai==1.1.7
langchain-tavily==0.2.16
langchain-text-splitters==1.1.0
langdetect==1.0.9
langgraph==1.0.5
langgraph-checkpoint==3.0.1
langgraph-prebuilt==1.0.5
langgraph-sdk==0.3.1
langsmith==0.6.0
lxml==6.0.2
Markdown==3.10
MarkupSafe==3.0.3
marshmallow==3.26.2
matplotlib-inline==0.2.1
mcp==1.25.0
mpmath==1.3.0
multidict==6.7.0
mypy_extensions==1.1.0
nest-asyncio==1.6.0
networkx==3.6.1
nltk==3.9.2
numpy==2.4.0
olefile==0.47
openai==2.14.0
orjson==3.11.5
ormsgpack==1.12.1
packaging==25.0
pandas==2.3.3
parso==0.8.5
pillow==12.1.0
platformdirs==4.5.1
prompt_toolkit==3.0.52
propcache==0.4.1
protobuf==6.33.3
psutil==7.2.1
pure_eval==0.2.3
pyasn1==0.6.1
pyasn1_modules==0.4.2
pycparser==2.23
pydantic==2.12.5
pydantic-settings==2.12.0
pydantic_core==2.41.5
Pygments==2.19.2
PyJWT==2.10.1
pymilvus==2.6.6
pypdf==6.6.0
python-dateutil==2.9.0.post0
python-docx==1.2.0
python-dotenv==1.2.1
python-iso639==2025.11.16
python-magic==0.4.27
python-multipart==0.0.21
python-oxmsg==0.0.2
pytz==2025.2
pywin32==311
PyYAML==6.0.3
pyzmq==27.1.0
RapidFuzz==3.14.3
referencing==0.37.0
regex==2025.11.3
requests==2.32.5
requests-toolbelt==1.0.0
rpds-py==0.30.0
rsa==4.9.1
safetensors==0.7.0
scikit-learn==1.8.0
scipy==1.17.0
sentence-transformers==5.2.0
setuptools==80.9.0
six==1.17.0
sniffio==1.3.1
soupsieve==2.8.1
SQLAlchemy==2.0.45
sse-starlette==3.1.2
stack-data==0.6.3
starlette==0.51.0
sympy==1.14.0
tavily==1.1.0
tenacity==9.1.2
threadpoolctl==3.6.0
tiktoken==0.12.0
tokenizers==0.22.2
torch==2.9.1
tornado==6.5.4
tqdm==4.67.1
traitlets==5.14.3
transformers==4.57.3
typing-inspect==0.9.0
typing-inspection==0.4.2
typing_extensions==4.15.0
tzdata==2025.3
unstructured==0.18.27
unstructured-client==0.42.6
urllib3==2.6.2
uuid_utils==0.12.0
uvicorn==0.40.0
wcmatch==10.1
wcwidth==0.2.14
webencodings==0.5.1
websockets==15.0.1
wrapt==2.0.1
xxhash==3.6.0
yarl==1.22.0
zstandard==0.25.0

OPENAI_API_KEY=sk-xxx

OPENAI_BASE_URL=https://api.openai-proxy.org/v1

# 第一次使用需要先安装依赖 
# pip install python-dotenv / uv add python-dotenv

# 1、从dotenv导入load_dotenv方法
from dotenv import load_dotenv 

 

# 2、调用load_dotenv方法加载.env文件
load_dotenv() 

 

# 3、通过os模块读取环境变量
import os
api_key = os.getenv("OPENAI_API_KEY")
print(api_key)

# pip install openai / uv add openai
from openai import OpenAI

import os

from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
  base_url=os.getenv("OPENAI_BASE_URL"),  # 平台提供的 URL
  api_key=os.getenv("OPENAI_API_KEY"),  # 平台提供的 API-Key
)

completion = client.chat.completions.create(
  model="gpt-5.5",  # 模型名称
  messages=[{"role": "user", "content": "将'你好'翻译成意大利语"}],  # 用户输入
)

print(completion.choices[0].message.content)

import os
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
  model="gpt-5.1",
  input="中国国内今天发生了哪些大事儿？",
  tools=[{"type": "web_search"}] # 可以自动调用内置工具
)

 

print(response.output_text)

# pip install google-genai  /uv add google-genai

def call_gemini():
    import os

    from google import genai

    from dotenv import load_dotenv

    load_dotenv()

    client = genai.Client(

        api_key=os.getenv("OPENAI_API_KEY"),

        http_options={

            "base_url": 'https://api.openai-proxy.org/google'  # 此处需要根据个人所选择的大模型服务平台去做具体调整

        },

    )

    response = client.models.generate_content(

        model="gemini-2.5-flash-lite",

        contents="你是谁，能做什么",

    )


print(response.text)

# pip install langchain

# pip install langchain-openai

def get_model_from_init():

  import os

  import dotenv

  dotenv.load_dotenv()

  from langchain.chat_models import init_chat_model

 

  llm = init_chat_model(

    model="gpt-5.5",

    model_provider="openai",

    base_url=os.getenv("OPENAI_BASE_URL"),

    api_key=os.getenv("OPENAI_API_KEY"),

  )

  resp = llm.invoke("你好")

  print(type(resp))  # <class 'langchain_core.messages.ai.AIMessage'>

  print(resp.content) # 获取结果

def get_model_from_openai_package():
  import os
  import dotenv
  dotenv.load_dotenv()
  
  from langchain_openai import ChatOpenAI
  llm = ChatOpenAI(
    model="gpt-5.5",
    temperature=0.0,
    base_url=os.getenv("OPENAI_BASE_URL"),
    api_key=os.getenv("OPENAI_API_KEY"),
  )

  resp = llm.invoke("你好")
  
  print(type(resp))
  print(resp.content)
  
if name == "main":
  get_model_from_openai_package()

def invoke_llm_with_message_list():

  import os
  from langchain_openai import ChatOpenAI
  from langchain_core.messages import HumanMessage,SystemMessage,AIMessage

  llm = ChatOpenAI(
    model="gpt-5.5",
    temperature=0.0,
    base_url=os.getenv("OPENAI_BASE_URL"),
    api_key=os.getenv("OPENAI_API_KEY"),
  )

  resp = llm.invoke([SystemMessage(content="你是一个专业的数学助手"),HumanMessage(content="你好，你是谁")])
  print(type(resp))
  print(resp.content)

if name == "main":
  invoke_llm_with_message_list()

def invoke_llm_with_message_list_use_tuple():
  import os
  import dotenv
  dotenv.load_dotenv()

  from langchain_openai import ChatOpenAI

  from langchain_core.messages import HumanMessage,SystemMessage,AIMessage

  llm = ChatOpenAI(
    model="gpt-5.5",
    temperature=0.0,
    base_url=os.getenv("OPENAI_BASE_URL"),
    api_key=os.getenv("OPENAI_API_KEY"),
  )

  # 以下两种方式是等价的
  messages_list = [("system","你是一个专业的数学助手"),("user","你好，你是谁")]

  message_list = [{"role":"system","content":"你是一个专业的数学助手"},{"role":"user","content":"你好，你是谁"}]

  resp = llm.invoke(message_list)
  print(type(resp))
  print(resp.content)

if name == "main":
invoke_llm_with_message_list_use_tuple()

import asyncio

async def call_llm_async():
  from langchain_openai import ChatOpenAI
  llm = ChatOpenAI(
    model="gpt-5.5"
  )

  response = await llm.ainvoke(
    input=[("user", "什么是LangChain")]
  )

  print(response.content)

if name == "main":
  asyncio.run(call_llm_async())

def call_llm_streaming_mode():
  from langchain_openai import ChatOpenAI
  llm = ChatOpenAI(
    model="gpt-5.5"
  )

  # 调用stream方法，返回迭代器对象

  response = llm.stream(

    input=[("user", "什么是LangChain")]

  )

  # 遍历迭代器对象，打印每个chunk的内容

  for chunk in response:

    print(chunk.content,end="")

 

call_llm_streaming_mode()

def call_llm_batch_mode():
  from langchain_openai import ChatOpenAI
  llm = ChatOpenAI(
    model="gpt-5.5"
  )

  # 调用batch方法，底部通过thread 并行调用模型
  response = llm.batch(
    inputs=[[("user", "什么是LangChain")],("user","LangChain的核心价值是什么呢？")]
  )

  # 打印每个问题的回答
  for question_chunk in response:
    print(question_chunk.content)
    
call_llm_batch_mode()

# pip install langchain-ollama
from langchain_ollama import ChatOllama
ollama_llm = ChatOllama(model="qwen3:8b")

messages = {"role": "user", "content": "你好，请介绍一下你自己"}
resp = ollama_llm.invoke(messages)
print(resp.content)

若 Ollama 不在本地默认端口运行，需指定 base_url
# pip install langchain-ollama
from langchain_ollama import ChatOllama
ollama_llm = ChatOllama(
  model="qwen3",  base_url="http://localhost:11434", 
)

messages = {"role": "user", "content": "你好，请介绍一下你自己"}
resp = ollama_llm.invoke(messages)
print(resp.content)

def json_output_parser():
  import os
  from langchain_openai import ChatOpenAI
  from langchain_core.output_parsers import JsonOutputParser
  from pydantic import BaseModel, Field

  llm = ChatOpenAI(
    model="gpt-5.5",
    temperature=0.0,
    base_url=os.getenv("OPENAI_BASE_URL"),
    api_key=os.getenv("OPENAI_API_KEY")
  )

  class Prime(BaseModel):
    prime: list[int] = Field(description="素数")
    count: list[int] = Field(description="小于该素数的素数个数")
  json_parser = JsonOutputParser(pydantic_object=Prime)

  # print(json_parser.get_format_instructions())
  res = llm.invoke([("system",json_parser.get_format_instructions()),("user","任意生成5个1000-100000之间素数，并标出小于该素数的素数个数")])
  print(res.content)
  parsed_res = json_parser.invoke(res)
  print(type(parsed_res))

def openai_json_output_demo():
  import os
  from openai import OpenAI
  from pydantic import BaseModel 

  client = OpenAI()
  class CalendarEvent(BaseModel):
    name: str
    date: str
    participants: list[str]


  response = client.chat.completions.parse(
    model="gpt-5.5",
    messages=[
      {
        "role": "user",
        "content": "Alice and Bob are going to a science fair on Friday.",
      }
    ],
    response_format=CalendarEvent
  )

  print(response.choices[0].message.parsed)

def gemini_json_output_demo():
  import os
  from google import genai
  from pydantic import BaseModel, Field
  from typing import List, Optional

  # 1、定义一个Pydantic模型，用于表示日历事件
  class CalendarEvent(BaseModel):
    name: str
    date: str
    participants: list[str]

  # 2、初始化Gemini客户端
  client = genai.Client(
    api_key=os.getenv("OPENAI_API_KEY"),
    vertexai=True, # 可选，优先使用vertexai协议访问，稳定性更高
    http_options={
      "base_url": 'https://api.openai-proxy.org/google',
    },
  )

  # 3、定义一个提示模板，用于生成日历事件
  prompt = """
  Alice and Bob are going to a science fair on Friday.

  """

  # 4、调用Gemini模型生成内容
  response = client.models.generate_content(
    model="gemini-2.5-flash-lite",
    contents=prompt,
    config={
      "response_mime_type": "application/json",
      "response_json_schema": CalendarEvent.model_json_schema(),
    },  
  )
  print(response.text)
  
 # 5、解析Gemini模型的响应,将JSON字符串转换为CalendarEvent对象
  event = CalendarEvent.model_validate_json(response.text)
  print(event)

def json_output_use_langchain():
  import os
  from langchain_openai import ChatOpenAI
  from langchain_google_genai import ChatGoogleGenerativeAI
  from langchain_core.messages import HumanMessage,SystemMessage,AIMessage
  from langchain_core.output_parsers import JsonOutputParser
  from pydantic import BaseModel, Field

  # 1、初始化llm: 可以使用OpenAI,也可以使用Gemini
  llm = ChatOpenAI(
    model="gpt-5.5",
    temperature=0.0,
    base_url=os.getenv("OPENAI_BASE_URL"),
    api_key=os.getenv("OPENAI_API_KEY")
  )

  # llm = ChatGoogleGenerativeAI(
  #   model="gemini-2.5-flash-lite",
  #   temperature=0.0,
  #   base_url='https://api.openai-proxy.org/google',
  #   api_key=os.getenv("OPENAI_API_KEY"),
  # )

  # 2、定义一个Pydantic模型，用于表示日历事件
  class CalendarEvent(BaseModel):
    name: str
    date: str
    participants: list[str]
  
  #3、使用with_structured_output，得到一个新的llm，用于生成结构化输出
  new_llm=llm.with_structured_output(schema=CalendarEvent)

  #4、调用新的llm，生成结构化输出
  res = new_llm.invoke("Alice and Bob are going to a science fair on Friday.")
  print(res)
  print(type(res))

all = [
  "BaseCumulativeTransformOutputParser",
  "BaseGenerationOutputParser",
  "BaseLLMOutputParser",
  "BaseOutputParser",
  "BaseTransformOutputParser",
  "CommaSeparatedListOutputParser",
  "JsonOutputKeyToolsParser",
  "JsonOutputParser",
  "JsonOutputToolsParser",
  "ListOutputParser",
  "MarkdownListOutputParser",
  "NumberedListOutputParser",
  "PydanticOutputParser",
  "PydanticToolsParser",
  "SimpleJsonOutputParser",
  "StrOutputParser",
  "XMLOutputParser",
]

def prompt_template_demo():
  from langchain_core.prompts import ChatPromptTemplate
  from langchain.chat_models import init_chat_model
  
  # 使用构造方法实例化提示词模板
  chat_prompt_template = ChatPromptTemplate.from_messages(
    messages=[
      ("system", "你是一个专业的评论员"),
      ("human", "请评价{product}的优缺点，包括{aspect1}和{aspect2}。"),
    ],
  )

  chat_message_list = chat_prompt_template.invoke({"product": "iPhone 15", "aspect1": "性能", "aspect2": "外观"})

  llm = init_chat_model(
    model="gpt-5.5",
    model_provider="openai",
  )
  resp = llm.invoke(chat_message_list)
	print(resp.content)

prompt_text = prompt.format(topic="猫")  # 方法1
model_out = model.generate(prompt_text)  # 方法2
result = parser.parse(model_out)  # 方法3
Runnable 统一调用方式：

# 分步调用
prompt_text = prompt.invoke({"topic": "猫"})  # 方法1
model_out = model.invoke(prompt_text)  # 方法2
result = parser.invoke(model_out)  # 方法3

# LCEL管道式
chain = prompt | model | parser  # 用管道符组合
result = chain.invoke({"topic": "猫"})  # 所有组件统一用invoke

chain = runnable1 | runnable2
# 等同于
chain = RunnableSequence([runnable1, runnable2])

import os
from langchain.chat_models import init_chat_model
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt_template = PromptTemplate(
  template="讲一个关于{topic}的笑话",
  input_variables=["topic"],
)

llm = init_chat_model(
  model="gpt-5.5",
  model_provider="openai", # 注意，此处没有再传入base_url=xxx 是因为默认也会读取相关环境变量，
)

parser = StrOutputParser()
chain = prompt_template | llm | parser
resp = chain.invoke({"topic": "人工智能"})
print(resp)

def runnable_parallel_demo():
  import os
  from langchain.chat_models import init_chat_model
  from langchain_core.prompts import PromptTemplate
  from langchain_core.runnables import RunnableParallel
  from langchain_core.output_parsers import StrOutputParser

  llm = init_chat_model(
    model="gpt-5.5",
    model_provider="openai",
  )

  english_chain = (
    PromptTemplate.from_template("把这个句子{topic}翻译成英文") | llm | StrOutputParser()
  )

  korean_chain = (
    PromptTemplate.from_template("把这个句子{topic}翻译成韩文") | llm | StrOutputParser()
  )

  map_chain = RunnableParallel(english=english_chain, korean=korean_chain)
  resp = map_chain.invoke({"topic": "人工智能是一种智能技术"})
  print(resp)
if name == "main":
runnable_parallel_demo()

def runnable_parallel_use_lcel_demo():
  import os
  from langchain.chat_models import init_chat_model
  from langchain_core.prompts import PromptTemplate
  from langchain_core.output_parsers import StrOutputParser

  # 1、初始化两个模型
  llm = init_chat_model(
    model="gpt-5.5",
    model_provider="openai",
  )

  deepseek_llm = init_chat_model(
    model="deepseek-chat",
    model_provider="deepseek",
  )
  # 2、创建两个并行运行的chain：使用两个不同的模型回答同一个问题，用以对比结果
  paragraph_1_chain = (
    PromptTemplate.from_template("对这首诗{poem}做一下赏析，分析它蕴含的含义") | llm | StrOutputParser()
  )

  paragraph_2_chain = (
    PromptTemplate.from_template("对这首诗{poem}做一下赏析，分析它蕴含的含义") | llm | StrOutputParser()
  )

  # 3、对前面的两个chain的结果进行分析总结
  summary_chain = (
    PromptTemplate.from_template("这两种赏析，第一种：{paragraph_1}，第二种：{paragraph_2}，哪个更好，为什么") | llm | StrOutputParser()

  ) 

  # 4、构造LCEL：将前面的两个chain并行运行，然后将结果传递给summary_chain

  map_chain = {

    "paragraph_1": paragraph_1_chain,

    "paragraph_2": paragraph_2_chain,

  } | summary_chain

  poem= """

  菩提本无树，

  明镜亦非台，

  本来无一物，

  何处惹尘埃。

  """

  # 5、运行LCEL
  resp = map_chain.invoke({"poem": poem})
  print(resp)

if name == "main":
runnable_parallel_use_lcel_demo()

#pip install markdown langchain_community unstructured[md]
def markdown_loader_demo():
  from langchain_community.document_loaders import UnstructuredMarkdownLoader
  loader = UnstructuredMarkdownLoader("./assets/sample.md",encoding="utf-8",mode="elements")
  docs = loader.load()
  for doc in docs:
    print(doc.page_content,end="\n============\n")

if __name__ == "__main__":
  markdown_loader_demo()

# pip install unstructured[docx]
def word_loader_demo():
  from langchain_community.document_loaders import UnstructuredWordDocumentLoader
  docs = UnstructuredWordDocumentLoader(
    # 文件路径
    file_path="assets/sample.docx",
    # 加载模式:
    #  single 返回单个Document对象
    #  elements 按标题等元素切分文档
    mode="elements",
  ).load()

  for doc in docs[230:260]: # 从文档中间选取30个文档查看结构
    print(doc.page_content)
    print(doc.metadata,end="\n============\n")

if __name__ == "__main__":
word_loader_demo()

def mineru_upload_file_demo():
  import requests
  import os
  token = os.getenv("MINERU_TOKEN")
  url = "https://mineru.net/api/v4/file-urls/batch"

  header = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {token}"
  }

  data = {
  "files": [
    {"name":"demo.pdf", "data_id": "abcd"}
  ],
  "model_version":"vlm"
  }

  file_path = [r"D:\PycharmProjects\lessons\demo_class\LangGraph_demo\langchain_demo\05_retrieval\assets\尚硅谷大模型技术之NLP1.0.2.pdf"]

  try:
    response = requests.post(url,headers=header,json=data)
    if response.status_code == 200:
      result = response.json()
      print('上传成功:{}'.format(result))
      batch_id = result'data'
      if result["code"] == 0:
        batch_id = result"data"
        urls = result"data"
        print('batch_id:{},urls:{}'.format(batch_id, urls))
        for i in range(0, len(urls)):
          with open(file_path[i], 'rb') as f:
            res_upload = requests.put(urls[i], data=f)
            if res_upload.status_code == 200:
              print(f"{urls[i]} 上传成功")
            else:
              print(f"{urls[i]} 上传失败")
      else:
        print('apply upload url failed,reason:{}'.format(result.msg))
      return batch_id
    else:
      print(f"请求失败，状态码：{response.status_code}，响应内容：{response.text}")
  except Exception as err:
    print(err)

上传完成之后，可以通过获取任务结果API来获取解析结果：

def mineru_check_result_demo(batch_id):

  import requests
  import time
  
  token = os.getenv("MINERU_TOKEN")
  url = f"https://mineru.net/api/v4/extract-results/batch/{batch_id}"
  header = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {token}"
  }

  res = requests.get(url, headers=header)

  while res.json()"data"0 != 'done':
    print('当前状态为running，等待3秒后重试')
    time.sleep(3)
    res = requests.get(url, headers=header)
    print(res.status_code)
    print(res.json()"data"0,end="\n\n=========\n\n")
  print('提取结果为:',res.json()"data"0)

# pip install langchain-text-splitters

from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import UnstructuredWordDocumentLoader

# 加载文档
docs = UnstructuredWordDocumentLoader(
  file_path="assets/sample.docx", mode="single"
).load()

# 切分为文本块
chunks = RecursiveCharacterTextSplitter(
  separators=["\n\n", "\n", "。", "！", "？", "……", "，", ""],  # 分隔符列表
  chunk_size=400,  # 每个块的最大长度
  chunk_overlap=50,  # 每个块重叠的长度
  length_function=len,  # 可选：计算文本长度的函数，默认为字符串长度，可自定义函数来实现按 token 数切分
  add_start_index=True,  # 可选：块的元数据中添加此块起始索引
).split_documents(docs) 

print(chunks)

@abstractmethod

  def embed_documents(self, texts: list[str]) -> list[list[float]]:
    """Embed search docs.
    Args:
      texts: List of text to embed.
    Returns:
      List of embeddings.
    """


  @abstractmethod
  def embed_query(self, text: str) -> list[float]:
    """Embed query text.
    Args:
      text: Text to embed.
    Returns:
      Embedding.
    """  

# pip install sentence-transformers langchain_huggingface

def embedding_demo():
  from langchain_huggingface import HuggingFaceEmbeddings
  embed_model = HuggingFaceEmbeddings(
    model_name=r'.\assets\models\bge-base-zh-v1.5'

  )

  # 单文本嵌入
  query = "你好，世界"
  query_result = embed_model.embed_query(query)
  print(len(query_result))
  print(query_result[0:10])

  # 多文本嵌入
  docs = ["你好，世界", "你好，世界"]
  res = embed_model.embed_documents(docs)
  print(type(res))
 
if name == "main":
  embedding_demo()

# pip install FlagEmbedding==1.3.5
from FlagEmbedding import BGEM3FlagModel

model = BGEM3FlagModel(model_name_or_path=r"D:\PycharmProjects\lessons\demo_class\LangChainDemo\04_retrieval\assets\models\bge-m3")
res = model.encode(["标量字段通常用来存储一些元数据，并可以在搜索时通过元数据进行过滤"],return_sparse=True,return_dense=True)
print('encode结果为：',res,end='\n\n')

# 1、打印稀疏向量
print('稀疏向量为：',res["lexical_weights"],end='\n\n')
# 2、将稀疏向量当中的id转换为token，并打印
sparse_vecs = model.convert_id_to_token(res["lexical_weights"])
print('稀疏向量转换为token后的结果为：',sparse_vecs,end='\n\n')
# 3、打印稠密向量
print('稠密向量为：',res["dense_vecs"],end='\n\n')

# pip install pymilvus
def get_milvus_client():
  from pymilvus import MilvusClient
  client = MilvusClient(
    uri="http://localhost:19530",
    token="",
  )

  res = client.list_collections()
  print(res)
  return client

def build_schema():
  from pymilvus import MilvusClient, DataType
  return (
    MilvusClient.create_schema(
      # 自动为id字段赋值
      auto_id=True,
    )
    # 添加 id 字段，类型为整数，设置为主键
    .add_field(field_name="id", datatype=DataType.INT64, is_primary=True)

    # 添加 vector 字段，类型为浮点数向量，维度为 1024
    .add_field(field_name="vector", datatype=DataType.FLOAT_VECTOR, dim=1024)
  
    # 添加 text 字段，类型为字符串，最大长度为 1500
    .add_field(field_name="text", datatype=DataType.VARCHAR, max_length=1500)

    # 添加 metadata 字段，类型为 JSON
    .add_field(field_name="metadata", datatype=DataType.JSON)
    .add_field(field_name="sparse_vector",datatype=DataType.SPARSE_FLOAT_VECTOR)
  )

def build_index():
  from pymilvus import MilvusClient, DataType
  index_params = MilvusClient.prepare_index_params()
  
  index_params.add_index(
    field_name="vector",  # 建立索引的字段
    index_type="HNSW",  # 索引类型
    metric_type="L2",  # 向量相似度度量方式
  )

  index_params.add_index(
    field_name="sparse_vector",
    index_type="SPARSE_INVERTED_INDEX",
    metric_type="IP",
  )

  return index_params

 

def create_collection(client):
  from pprint import pprint
  client.drop_collection(collection_name="demo_collection")
  
  if not client.has_collection(collection_name="demo_collection"):
    print("collection demo_collection not exists, create it")
    client.create_collection(
      collection_name="demo_collection",  # collection 名称
      schema=build_schema(),  # collection 的 schema
      index_params=build_index(),  # collection 的 index
    )

    # 查看 collection
    print(client.list_collections())
 

    # 查看 collection 描述
    pprint(client.describe_collection(collection_name="demo_collection"))
create_collection(get_milvus_client())

from pymilvus import MilvusClient,DataType
def get_client():
  return MilvusClient(uri="http://localhost:19530",token="")

 

def insert_data(client:MilvusClient,collection_name:str):

  """

  构建数据，并插入到collection中

  """

 
  # 1、加载一个文件:此处以assets/sample.docx文件为例
  from langchain_community.document_loaders import UnstructuredWordDocumentLoader
  doc_list = UnstructuredWordDocumentLoader("assets/sample.docx",mode="single").load()
  # 2、切分文件
  from langchain_text_splitters import RecursiveCharacterTextSplitter
  text_splitter = RecursiveCharacterTextSplitter(chunk_size=500,chunk_overlap=50,separators=["\n\n","\n","。"])
  splitted_doc_list =text_splitter.split_documents(doc_list)
  splitted_doc_list = splitted_doc_list[0:20]

  # 查看当前文本列表当中最大的文本长度
  max_len = max([len(bytes(doc.page_content.encode("utf-8"))) for doc in splitted_doc_list])
  print('当前最大长度是：',max_len)
  
  # 3、构建向量：稠密向量，稀疏向量
  from FlagEmbedding import BGEM3FlagModel

  model = BGEM3FlagModel("assets/models/bge-m3") # 需要安装 带cuda的torch 
  all_vectors = model.encode([doc.page_content for doc in splitted_doc_list],return_dense=True,return_sparse=True)

  dense_vectors = all_vectors["dense_vecs"]
  sparse_vectors = all_vectors['lexical_weights']


  # 4、准备数据：组装成List[Dict]
  insert_data_list=[]
  for doc, dense_vector, sparse_vector in zip(splitted_doc_list,dense_vectors,sparse_vectors):
    insert_data_list.append({
      "vector":dense_vector,
      "sparse_vector":sparse_vector,
      "metadata":doc.metadata,
      "text":doc.page_content
    })

  # 5、调用client.insert()方法，插入数据
  res = client.insert(
    collection_name=collection_name,
    data=insert_data_list
  )
  # 有多少条数据插入成功
  print(res) 

def delete_demo(client):
  res = client.delete(
    collection_name="demo_collection",
    # 过滤条件，仅删除 id 在指定范围内的实体,也可以传递其他字段的过滤条件
    filter="id in [463480757150366907, 463480757150366908]",
  )

  print(res)

if name == "main":
  client = get_milvus_client()
delete_demo(client)

from typing import Any, Dict, List, Tuple
COLLECTION_NAME = "demo_collection"

def get_milvus_client(uri: str = "http://localhost:19530", token: str = ""):
  from pymilvus import MilvusClient
  return MilvusClient(uri=uri, token=token) 

def get_bge_m3_model():
  from FlagEmbedding import BGEM3FlagModel
  return BGEM3FlagModel(model_name_or_path="./assets/models/bge-m3") 

def encode_query(model, query: str) -> Tuple[List[float], Dict[int, float]]:
  all_embeddings = model.encode([query], return_dense=True, return_sparse=True)
  dense_vec = all_embeddings"dense_vecs"
  sparse_raw = all_embeddings"lexical_weights
  return dense_vec, sparse_vec 

def print_hits(title: str, hits: List[dict]):
  print("\n" + "="  20)
  print(title)
  print("="  20)
  for i, hit in enumerate(hits, start=1):
    entity = hit.get("entity", {})
    print(
      {
        "rank": i,
        "id": entity.get("id"),
        "distance": hit.get("distance"),
        "text": entity.get("text"),
        "metadata": entity.get("metadata"),
      }
    )
 
def dense_vector_search_example(client, query: str, limit: int = 5):
  model = get_bge_m3_model()
  dense_vec, _ = encode_query(model, query)

  results = client.search(
    collection_name=COLLECTION_NAME,
    data=[dense_vec],
    anns_field="vector",
    limit=limit,
    search_params={"metric_type": "L2"},
    output_fields=["id", "text", "metadata"],
  )

  print_hits("稠密向量检索（vector）", results[0])
  return results

 

def sparse_vector_search_example(client, query: str, limit: int = 5):
  model = get_bge_m3_model()
  _, sparse_vec = encode_query(model, query)

  results = client.search(
    collection_name=COLLECTION_NAME,
    data=[sparse_vec],
    anns_field="sparse_vector",
    limit=limit,
    search_params={"metric_type": "IP"},
    output_fields=["id", "text", "metadata"],
  )

  print_hits("稀疏向量检索（sparse_vector）", results[0])
  return results

def hybrid_vector_search_example_rrf(client, query: str, limit: int = 5):
  from pymilvus import AnnSearchRequest, RRFRanker
  model = get_bge_m3_model()
  dense_vec, sparse_vec = encode_query(model, query)

  dense_req = AnnSearchRequest(
    data=[dense_vec],
    anns_field="vector",
    param={"metric_type": "L2"},
    limit=limit,
  )

  sparse_req = AnnSearchRequest(
    data=[sparse_vec],
    anns_field="sparse_vector",
    param={"metric_type": "IP"},
    limit=limit,
  ) 

  results = client.hybrid_search(
    collection_name=COLLECTION_NAME,
    reqs=[dense_req, sparse_req],
    ranker=RRFRanker(k=60),
    limit=limit,
    output_fields=["id", "text", "metadata"],
  )

  print_hits("混合向量检索（RRF 融合稠密+稀疏）", results[0])
  return results

def scalar_query_examples(client, like_keyword: str = "大模型"):
  # 对text字段进行检索
  try:
    like_res = client.query(
      collection_name=COLLECTION_NAME,
      filter=f'text like "%{like_keyword}%"',
      output_fields=["id", "text"],
      limit=5,
    )
    
    print("\n" + "="  20)
    print(f'标量检索（query: text like "%{like_keyword}%"）')
    print("="  20)
    for row in like_res:
      print({"id": row.get("id"), "text": row.get("text")})
  except Exception as e:
    print("VARCHAR like 过滤失败：", e)

  # 对metadata字段进行检索
  try:
    json_res = client.query(
      collection_name=COLLECTION_NAME,
      filter='metadata["source"] like "%sample%"',
      output_fields=["id", "metadata"],
      limit=5,
    )

    print("\n" + "="  20)
    print('标量检索（query: metadata["source"] like "%sample%"）')
    print("="  20)
    for row in json_res:
      print({"id": row.get("id"), "metadata": row.get("metadata")})
  except Exception as e:
    print("JSON 过滤失败（metadata 结构不匹配或不支持该表达式）：", e)

def rag_demo(client:MilvusClient,query):
  from langchain_openai import ChatOpenAI
  # 加载模型

  llm = ChatOpenAI(model_name="gpt-5.5")
  retrieval_res = hybrid_vector_search_example_rrf(client=client,query=query)

  # 构建上下文
  context = "\n".join([data["text"] for data in retrieval_res])
  message_list=[
    {"role": "system", "content": "你是一个专业的法律问答机器人，请根据上下文回答问题，当上下文无法回答问题时，请回答“根据上下文无法回答该问题”"},
    {"role": "user", "content": f"根据以下上下文回答问题：{context}\n问题：{query}"}
  ]
 

  # 生成文本
  res = llm.invoke(message_list)
  print(res)

if __name__ == "__main__":
  client = get_milvus_client()
  rag_chain_demo(client,'不动产被占有了怎么办？')

from openai import OpenAI
import json

client = OpenAI()

# 1. 通过JSON结构定义工具，包括工具名称，描述，参数等
tools = [
  {
    "type": "function",
    "function": {
      "name": "get_weather",
      "description": "Get today's weather for a location.",
      "parameters": {
        "type": "object",
        "properties": {
          "city": {
            "type": "string",
            "description": "城市名称, e.g. San Francisco",
          },
          "date" :{
            "type":"string",
            "description":"想要查询的天气的日期, e.g. 2023-12-25"
          }
        },
        "required": ["city","date"],
        "additionalProperties": False,
      },
      "strict": True,
    },
  },
]
def get_weather(city,date):
  return f"{city} on {date} is cloudy with a chance of rain."

messages = [
  {"role": "user", "content": "What is the weather like in 北京 on 2024-12-25?"}
]

# 2. Prompt the model with tools defined
response = client.chat.completions.create(
  model="gpt-4.1",
  messages=messages,
  tools=tools,
)
messages.append(response.choices[0].message)

for tool_call in response.choices[0].message.tool_calls or []:
  if tool_call.function.name == "get_weather":
    # 3. 执行工具函数的逻辑
    args = json.loads(tool_call.function.arguments)
    weather = get_weather(args["city"],args["date"])

    # 4. 将工具函数的执行结果添加到消息列表中
    messages.append(
      {
        "role": "tool",
        "tool_call_id": tool_call.id,
        "content": json.dumps({"weather": weather}),
      }
    )

response = client.chat.completions.create(
  model="gpt-4.1",
  messages=messages,
  tools=tools,
)

# 5. 模型会根据工具函数的执行结果，生成最终的回复
print(response.choices[0].message.content)

from langchain.tools import tool
from langchain_core.messages import HumanMessage,ToolMessage
import logging
logging.basicConfig(level=logging.DEBUG)

# 可选：通过BaseModel详细定义工具的参数
from pydantic import BaseModel,Field
class GetWeatherArgs(BaseModel):
  city: str = Field(description="城市名称")
  date: str = Field(description="日期，格式为YYYY-MM-DD")
  
@tool
def get_weather(city, date) -> str:
  """获取指定城市在指定日期的天气"""   
  return f"{city} 在 {date} 天气多云，有下雨的可能性"
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4.1")

llm = llm.bind_tools([get_weather])
message_list = [
  HumanMessage(content="北京2024-12-25的天气")
]

res = llm.invoke(message_list)
message_list.append(res) 

# 当前结果当中包含调用工具的出参
print('LLM的首次回复：',res)

# 解析调用工具的出参，手动调用工具
tool_call = res.tool_calls[0]
args = tool_call['args']
call_tool_res = get_weather.invoke(args)
id = tool_call['id']

#构造Message对象
tool_message = ToolMessage(tool_call_id=id,content=call_tool_res)
message_list.append(tool_message) 

res = llm.invoke(message_list) 

print('基于工具调用返回信息后，LLM的回复：',res)

# pip install langchain-tavily
import os
from langchain_tavily import TavilySearch
from langchain.agents import create_agent
from langchain.chat_models import init_chat_model

# 定义模型
llm = init_chat_model(
  model="gpt-5.5",
  model_provider="openai",
)

# 定义 Tavily 搜索工具
search = TavilySearch(max_results=5)
tools = [search]

# 创建 Agent
agent = create_agent(
  model=llm,  # 模型
  tools=tools,  # 工具
  system_prompt="你是位助手，需要调用工具来帮助用户。",  # 系统提示词
)

# 调用 Agent
res = agent.invoke(
  {"messages": [{"role": "user", "content": "今天北京的天气怎么样？"}]}
)

print(res)
如果 Agent 执行多个步骤，这可能需要一些时间。为了显示中间进度，我们可以使用 stream 流式返回消息。

# pip install langchain-tavily
import os
from langchain_tavily import TavilySearch
from langchain.agents import create_agent
from langchain.chat_models import init_chat_model
 
# 定义模型
llm = init_chat_model(
  model="gpt-5.5",
  model_provider="openai",
)

# 定义 Tavily 搜索工具
search = TavilySearch(max_results=5)
tools = [search]

# 创建 Agent
agent = create_agent(model=llm, tools=tools)

# 调用 Agent
for chunk in agent.stream(
  {
    "messages": [
      {"role": "system", "content": "你是位助手，需要调用工具来帮助用户。"},
      {"role": "user", "content": "今天北京的天气怎么样？"},
    ]
  }
):
print(chunk, end="\n\n")

LANGSMITH_TRACING="true"
LANGSMITH_API_KEY="..."

# pip install mcp
from mcp.server.fastmcp import FastMCP


# 创建 MCP 实例
mcp = FastMCP("Demo") 

# 为 MCP 实例添加工具
@mcp.tool()
def add(a: int, b: int) -> int:
  return a + b

# 为 MCP 实例添加资源
@mcp.resource("greeting://default")
def get_greeting() -> str:
  return "Hello from static resource!"
 
# 为 MCP 实例添加提示词
@mcp.prompt()
def greet_user(name: str, style: str = "friendly") -> str:
  styles = {
    "friendly": "写一句友善的问候",
    "formal": "写一句正式的问候",
    "casual": "写一句轻松的问候",
  }
  return f"为{name}{styles.get(style, styles['friendly'])}"
 
if name == "main":
  mcp.run(transport="stdio")

# pip install mcp
import asyncio
from mcp.client.stdio import stdio_client
from mcp import ClientSession, StdioServerParameters

async def stdio_run():
  server_params = StdioServerParameters(
    command=r" D:\PycharmProjects\ LangGraph_demo.venv\Scripts\python.exe", 
    args=[r"./mcp_server_stdio.py"],
  )

  async with stdio_client(server_params) as (read, write):
    async with ClientSession(read, write) as session:
      # 初始化连接
      await session.initialize()
      # 获取可用工具
      tools = await session.list_tools()
      print(tools)
      print()
      
      # 调用工具
      call_res = await session.call_tool("add", {"a": 1, "b": 2})
      print(call_res)
      print()

      # 获取可用资源
      resources = await session.list_resources()
      print(resources)
      print() 

      # 调用资源
      read_res = await session.read_resource("greeting://default")
      print(read_res)
      print()

      # 获取可用提示
      prompts = await session.list_prompts()
      print(prompts)
      print()
 
      # 调用提示
      get_res = await session.get_prompt("greet_user", {"name": "Jack"})
      print(get_res)
      print()

asyncio.run(stdio_run())

# pip install mcp
from mcp.server.fastmcp import FastMCP

# 创建 MCP 实例
mcp = FastMCP("Demo") 

# 为 MCP 实例添加工具
@mcp.tool()
def add(a: int, b: int) -> int:
  return a + b 

# 为 MCP 实例添加资源
@mcp.resource("greeting://default")
def get_greeting() -> str:
  return "Hello from static resource!"

# 为 MCP 实例添加提示词
@mcp.prompt()
def greet_user(name: str, style: str = "friendly") -> str:
  styles = {
    "friendly": "写一句友善的问候",
    "formal": "写一句正式的问候",
    "casual": "写一句轻松的问候",
  }
  return f"为{name}{styles.get(style, styles['friendly'])}"

if name == "main":
  # mcp.settings.host = "0.0.0.0"
  # mcp.settings.port = 8888
  mcp.run(transport="streamable-http")  # 默认启动在 127.0.0.1:8000

# pip install mcp
import asyncio
from mcp import ClientSession
from mcp.client.streamable_http import streamable_http_client

async def streamablehttp_run():
  url = "http://127.0.0.1:8000/mcp" 

  async with streamable_http_client(url=url) as (read,write,_):
    async with ClientSession(read,write) as session:
      # 初始化连接
      await session.initialize()
 
      # 获取可用工具
      tools = await session.list_tools()
      print(tools)
      print()

      # 调用工具
      call_res = await session.call_tool("add", {"a": 1, "b": 2})
      print(call_res)
      print()
      
      # 获取可用资源
      resources = await session.list_resources()
      print(resources)
      print() 

      # 调用资源
      read_res = await session.read_resource("greeting://default")
      print(read_res)
      print() 

      # 获取可用提示
      prompts = await session.list_prompts()
      print(prompts)
      print()

      # 调用提示
      get_res = await session.get_prompt("greet_user", {"name": "Jack"})
      print(get_res)
      print()

asyncio.run(streamablehttp_run())

# pip install langchain_mcp_adapters
from langchain_mcp_adapters.client import MultiServerMCPClient  
from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
from langgraph.checkpoint.memory import InMemorySaver
import asyncio
client = MultiServerMCPClient(  
  {
     "12306-mcp": {
   "transport": "streamable_http",
   "url": "https://mcp.api-inference.modelscope.net/c30f9b25034446/mcp"
  },
  #   "amap-maps": {
  #  "transport": "http",
  #  "url": "https://mcp.api-inference.modelscope.net/14db9c03451e47/mcp"
  # }
  }
)

def print_message(message):
  from langchain.messages import AIMessage,HumanMessage,ToolMessage
  if isinstance(message,AIMessage):
    print("AI回复：",message.content)
    print("AI决定调用工具",message.tool_calls)
  elif isinstance(message,HumanMessage):
    print("用户输入：",message.content)
  elif isinstance(message,ToolMessage):
    print("工具调用：",message.content)
  else:  
    print("未知消息类型")

async def main():
  tools = await client.get_tools()  
print(tools)
  def handle_tool_error(error) -> str:
    return f"Tool execution failed: {str(error)}"
  
  # 配置工具错误所对应的处理方式，避免工具调用错误导致整个agent执行过程退出
for tool in tools:
    tool.handle_tool_error = handle_tool_error
  llm = ChatOpenAI(
    model="gpt-5.5"
  )

  agent = create_agent(
    llm,
    tools,
  )
  while True:
    user_input = input(">")
    if user_input == "exit":
      break
    res = await agent.ainvoke({"messages": [{"role": "user", "content": user_input}]},config={"configurable":{"thread_id":"1"}})

    print(res'messages'.content,end="\n\n")
    for message in res["messages"]:
      print_message(message)
      print("\n")
    print("\n")

asyncio.run(main())

import os
import datetime
from langchain_tavily import TavilySearch
from langchain.agents import create_agent
from langchain.chat_models import init_chat_model
from langgraph.checkpoint.memory import InMemorySaver

# 定义 Tavily 搜索工具
search = TavilySearch(max_results=5)
tools = [search]

llm = init_chat_model(
  model="gpt-5.5",
  model_provider="openai",
)

# 关键点1：定义checkpointer实例
checkpointer = InMemorySaver()

# 创建 Agent
agent = create_agent(
  model=llm,
  tools=tools,
  checkpointer=checkpointer, # 关键点2：将checkpointer实例传递给Agent
)

# 调用
print("=== 第一次调用 ===")
for chunk in agent.stream(
  input={
    "messages": [
      {
        "role": "system",
        "content": f"当前时间：{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
      },
      {"role": "user", "content": "今天北京天气怎么样？"},
    ]
  },

  config={"configurable": {"thread_id": "abc123"}}, # 关键点3：为每个调用指定一个唯一的thread_id
):
  print(chunk, end="\n\n")

print("=== 第二次调用 ===")
for chunk in agent.stream(
  input={
    "messages": [
      {"role": "user", "content": "我刚才问你什么了"},
    ]
  },

  # 关键点4：在多次调用中使用相同的thread_id，模型会记住之前的对话
  config={"configurable": {"thread_id": "abcedf"}},
):
print(chunk, end="\n\n")

from langchain.agents.middleware.human_in_the_loop import HumanInTheLoopMiddleware
summarize_llm = ChatOpenAI(model="gpt-5.5")
summary_middleware = SummarizationMiddleware(model=summarize_llm,trigger=("messages", 10))

from langchain.agents.middleware.human_in_the_loop import HumanInTheLoopMiddleware
tool_name_to_interrupt = {'send_email':True,'get-current-date':False}
human_in_the_loop_middleware = HumanInTheLoopMiddleware(interrupt_on=tool_name_to_interrupt)

import asyncio
from typing import Literal

from langchain.agents import create_agent
from langchain.agents.middleware import HumanInTheLoopMiddleware
from langchain.chat_models import init_chat_model
from langchain.tools import tool
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.types import Command

# 1. 定义工具
@tool
def get_weather(city: str) -> str:
  """查询天气"""
  return f"{city}的天气晴朗，气温25度。" 

@tool
def transfer_money(amount: int, to_account: str) -> str:
  """转账工具 (敏感操作)"""
  print(f"!!! 正在执行转账: {amount} -> {to_account} !!!")
  return f"成功转账 {amount} 元给 {to_account}。"
 
# 2. 初始化模型
llm = init_chat_model("gpt-5.5", model_provider="openai") 
# 3. 配置 HumanInTheLoopMiddleware
# 我们希望在调用 transfer_money 时暂停，让用户审核
# True 表示允许所有操作 (approve, edit, reject)
interrupt_config = {
  "transfer_money": True,
  "get_weather": False # False 表示自动批准，不中断
}
hitl_middleware = HumanInTheLoopMiddleware(interrupt_on=interrupt_config)


# 4. 创建 Agent
# 注意：使用中断功能必须配置 checkpointer，因为中断需要保存状态
checkpointer = InMemorySaver()
agent = create_agent(
  model=llm,
  tools=[get_weather, transfer_money],
  middleware=[hitl_middleware],
  checkpointer=checkpointer,
) 

async def run_demo():
  print("=== HumanInTheLoopMiddleware 演示 ===")
  print("场景：用户让 Agent 转账，Agent 在执行前会暂停等待批准。")  
  thread_id = "thread-1"
  config = {"configurable": {"thread_id": thread_id}}
  
  # 第一步：用户发出指令,可以调整成查询天气
  print("\n[User]: 请帮我转账 100 元给 Alice")  

  # 使用 ainvoke 或 stream 运行
  # 如果遇到中断，LangGraph 会暂停并保存状态
  # 我们需要在一个循环中处理这种情况，但为了演示清晰，我们分步执行  

  # 第一次运行：Agent 思考 -> 决定调用 transfer_money -> Middleware 拦截 -> 中断
  # 注意：create_agent 返回的是一个 CompiledGraph，它的行为和标准 LangGraph 一致  

  # 我们用一个循环来模拟持续交互，并处理潜在的中断
  current_input = {"messages": [{"role": "user", "content": "请帮我转账 100 元给 Alice"}]}
  current_command = None 

  while True:
    try:
      # 如果有 resume command，就用它；否则用 input
      if current_command:
        result = await agent.ainvoke(current_command, config=config)
        current_command = None # 重置
      else:
        if not current_input:
          break
        result = await agent.ainvoke(current_input, config=config)
        current_input = None # 处理完了

      # 打印结果消息
      if "messages" in result:
        for msg in result["messages"]:
          if hasattr(msg, "tool_calls") and msg.tool_calls:
             print(f"[Agent]: 我想调用工具: {msg.tool_calls}")
          if msg.type == "tool":
             print(f"[Tool Output]: {msg.content}")
          if msg.type == "ai" and not msg.tool_calls:
             print(f"[Agent]: {msg.content}") 

    except Exception as e:
      print(f"发生错误: {e}")
      pass

    # 检查是否中断，当中断时，result当中有interrupt键
    if "interrupt" in result:
      interrupt_value = result"interrupt".value
      print(f"\n!!! 检测到中断 (Middleware 拦截) !!!")
      print(f"中断详情: {interrupt_value}")      

      # 这里模拟用户决策
      print("\n[System]: 请审核上述操作 (approve/reject/edit):")
      # 模拟用户输入 "approve"
      decision_type = "approve" 
      print(f"[User]: {decision_type}")      

      # 构建回复
      # Middleware 期望的格式是 {"decisions": [{"type": "approve", ...}]}
      decisions = []
      action_requests = interrupt_value.get("action_requests", [])      

      for req in action_requests:
        print(f"  - 批准操作: {req['name']}")
        decisions.append({"type": "approve"})      

      # 人工审核结果：通过构造 resume command，并传入的方式传入给agent
      current_command = Command(resume={"decisions": decisions})
      print("[System]: 恢复执行...")
      continue    

    # 如果没有中断，说明任务完成
    break
 
if name == "main":
  asyncio.run(run_demo())