非OpenAI模型使用Agents SDK
OpenAI Agents SDK使用了OpenAI的新的Responses API，有别于广泛得到支持的旧的OpenAI兼容API接口，因此非OpenAI模型无法直接利用OpenAI Agents SDK。
本综合指南演示了如何将官方的 OpenAI Agents SDK 与非OpenAI模型集成，以创建完全在本地基础设施上运行的 AI 代理。到结束时，你将了解本地托管 AI 代理的理论基础和一个Ollama集成的实际实现，同样的方法你也可以应用到其他模型。
1、简介
OpenAI Agents SDK 是一个强大的框架，用于构建可以通过规划和工具使用解决复杂任务的基于代理的 AI 系统。通过将其与 Ollama 集成，我们可以让这些代理在本地运行，从而提高隐私性、减少延迟并消除 API 成本。
什么是 OpenAI Agents SDK？
OpenAI Agents SDK（agents）是一个简化 AI 代理开发的框架。它提供了：
- 定义代理行为的结构化方法
- 内置工具使用和支持计划
- 多轮对话的会话管理
- 记忆和状态持久化
在其核心，该 SDK 正式化了从更广泛的 LLM 社区中出现的代理模式，为开发人员提供了一种标准的方式来实现可以计划、推理和执行复杂任务的代理。
什么是 Ollama？
Ollama 是一个开源框架，用于在本地运行大型语言模型（LLMs）。其主要功能包括：
- 易于安装和模型管理
- 兼容 OpenAI API 结构的 API 端点
- 支持许多开源模型（Llama、Mistral 等）
- 自定义模型创建和微调
为什么要集成它们？
集成提供了以下好处：
- 数据隐私：所有数据都保留在您的本地机器上
- 成本效率：无需按令牌支付 API 费用
- 定制化：针对特定用例微调模型
- 网络独立性：代理在没有互联网连接的情况下也能工作
- 降低延迟：消除网络往返
2、设置环境
2.1 安装Ollama
首先，按照您操作系统的说明安装 Ollama。
对于 macOS 和 Linux：
curl -fsSL https://ollama.ai/install.sh | sh
对于 Windows，从 Ollama 网站下载安装程序。
2.2 下载模型
拉取一个能够支持代理的模型。在这个指南中，我们将使用 Mistral：
ollama pull mistral
通过运行以下命令验证 Ollama 是否正常工作：
ollama run mistral "Hello, are you running correctly?"
你应该看到由模型生成的响应。
2.3 安装 OpenAI Agents SDK
克隆存储库并安装包：
git clone https://github.com/openai/openai-agents-python.git
cd openai-agents-python
pip install -e .
这将以开发模式安装包，允许您根据需要修改代码。
2.4 设置所需依赖项
安装其他依赖项：
pip install requests python-dotenv pydantic
3、将 Ollama 与 OpenAI Agents SDK 集成
OpenAI Agents SDK 使用 OpenAI Python 客户端作为底层。我们需要创建一个自定义客户端，将请求定向到 Ollama 而不是 OpenAI 的服务器。
3.1 创建自定义客户端
创建一个名为 ollama_client.py 的文件：
import os
from openai import OpenAI
class OllamaClient(OpenAI):
"""自定义 OpenAI 客户端，将请求路由到 Ollama。"""
def __init__(self, model_name="mistral", **kwargs):
# 配置以使用 Ollama 的端点
kwargs["base_url"] = "http://localhost:11434/v1"
# Ollama 不需要 API 密钥，但客户端期望有一个
kwargs["api_key"] = "ollama-placeholder-key"
super().__init__(**kwargs)
self.model_name = model_name
# 检查模型是否存在
print(f"使用 Ollama 模型: {model_name}")
def create_completion(self, *args, **kwargs):
# 如果未明确提供，则覆盖模型名称
if "model" not in kwargs:
kwargs["model"] = self.model_name
return super().create_completion(*args, **kwargs)
def create_chat_completion(self, *args, **kwargs):
# 如果未明确提供，则覆盖模型名称
if "model" not in kwargs:
kwargs["model"] = self.model_name
return super().create_chat_completion(*args, **kwargs)
# 这些方法是为了与 agents 库兼容而需要的
def completion(self, prompt, **kwargs):
if "model" not in kwargs:
kwargs["model"] = self.model_name
return self.completions.create(prompt=prompt, **kwargs)
def chat_completion(self, messages, **kwargs):
if "model" not in kwargs:
kwargs["model"] = self.model_name
return self.chat.completions.create(messages=messages, **kwargs)
3.2 为 OpenAI Agents SDK 创建适配器
现在我们将创建一个适配器，使 OpenAI Agents SDK 与我们的 Ollama 客户端兼容。创建一个名为 agent_adapter.py 的文件：
from ollama_client import OllamaClient
from openai.types.chat import ChatCompletion, ChatCompletionMessage
import agents.agent as agent_module
from agents.agent import Agent
from agents.run import Runner, RunConfig
from agents.models import _openai_shared
import json
import logging
# 配置日志记录
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
# 设置占位符 OpenAI API 密钥以避免初始化错误
_openai_shared.set_default_openai_key("placeholder-key")
# 存储原始的 Agent 类初始化
original_init = Agent.__init__
def patched_init(self, *args, **kwargs):
"""如果未提供，则替换模型为 OllamaClient。"""
if "model" not in kwargs:
kwargs["model"] = OllamaClient(model_name="mistral")
original_init(self, *args, **kwargs)
# 应用修补后的初始化
Agent.__init__ = patched_init
# 结构化工具调用的类
class ToolCall:
def __init__(self, name, inputs=None):
self.name = name
self.inputs = inputs or {}
# 定义一个响应类，匹配 main.py 所需的内容
class AgentResponse:
def __init__(self, result):
# 从最终输出中提取消息
if hasattr(result, 'final_output'):
if isinstance(result.final_output, str):
self.message = result.final_output
else:
self.message = str(result.final_output)
else:
self.message = "抱歉，我无法处理该请求。"
# 如果存在，获取对话 ID
self.conversation_id = getattr(result, 'conversation_id', None)
# 初始化 tool_calls
self.tool_calls = []
# 从 raw_responses 中提取工具调用
if hasattr(result, 'raw_responses'):
for response in result.raw_responses:
try:
if hasattr(response, 'output') and hasattr(response.output, 'tool_calls'):
for tool_call in response.output.tool_calls:
# 处理 tool_call 是字典的情况
if isinstance(tool_call, dict):
name = tool_call.get('name', 'unknown_tool')
inputs = tool_call.get('inputs', {})
self.tool_calls.append(ToolCall(name, inputs))
else:
``` # 假设它已经是具有 name 和 inputs 属性的对象
self.tool_calls.append(tool_call)
except Exception as e:
logger.error(f"提取工具调用时出错: {str(e)}")
# 为 Agent 类添加一个 run 方法
def run(self, message, conversation_id=None):
"""使用给定的消息运行代理。
参数:
message: 用户消息以进行处理
conversation_id: 可选的对话ID，用于连续性
返回:
包含消息、conversation_id 和 tool_calls 属性的响应对象
"""
try:
# 为模型创建直接提示
prompt = f"""
{self.instructions}
用户查询: {message}
"""
# 直接从模型获取响应（OllamaClient）
response = self.model.chat.completions.create(
model="mistral",
messages=[{"role": "user", "content": prompt}],
temperature=0.7,
)
# 提取文本响应
response_text = response.choices[0].message.content
# 创建仅包含响应文本的最小化结果对象
class MinimalResult:
def __init__(self, text, conv_id):
self.final_output = text
self.conversation_id = conv_id
self.raw_responses = []
result = MinimalResult(response_text, conversation_id)
# 返回响应对象
return AgentResponse(result)
except Exception as e:
import traceback
error_traceback = traceback.format_exc()
logger.error(f"运行代理时出错: {str(e)}\n{error_traceback}")
# 创建包含错误消息的基本响应
response = AgentResponse(None)
response.message = f"发生错误: {str(e)}"
return response
# 确保 run 方法应用于 Agent 类
Agent.run = run
# 调试语句 - 记录适配器加载情况
print("Agent 适配器已加载，Agent 类已修补 run 方法。")
4、构建文档分析代理
让我们构建一个实用的代理，该代理可以分析文档、提取关键信息并回答有关内容的问题。
4.1 创建文档记忆
首先，让我们创建一个简单的文档存储系统来存储和检索分析过的文档。创建一个名为 document_memory.py 的文件：
import os
import json
import hashlib
from typing import Dict, List, Optional
class DocumentMemory:
"""代理的简单文档存储系统。"""
def __init__(self, storage_dir: str = "./document_memory"):
self.storage_dir = storage_dir
os.makedirs(storage_dir, exist_ok=True)
self.index_file = os.path.join(storage_dir, "index.json")
self.document_index = self._load_index()
def _load_index(self) -> Dict:
"""从磁盘加载文档索引。"""
if os.path.exists(self.index_file):
with open(self.index_file, 'r') as f:
return json.load(f)
return {"documents": {}}
def _save_index(self):
"""将文档索引保存到磁盘。"""
with open(self.index_file, 'w') as f:
json.dump(self.document_index, f, indent=2)
def _generate_doc_id(self, url: str) -> str:
"""根据其URL生成文档的唯一ID。"""
return hashlib.md5(url.encode()).hexdigest()
def store_document(self, url: str, content: str, metadata: Optional[Dict] = None) -> str:
"""存储文档并返回其ID。"""
doc_id = self._generate_doc_id(url)
doc_path = os.path.join(self.storage_dir, f"{doc_id}.txt")
# 存储文档内容
with open(doc_path, 'w') as f:
f.write(content)
# 更新索引
self.document_index["documents"][doc_id] = {
"url": url,
"path": doc_path,
"metadata": metadata or {}
}
self._save_index()
return doc_id
def get_document(self, doc_id: str) -> Optional[Dict]:
"""通过ID检索文档。"""
if doc_id not in self.document_index["documents"]:
return None
doc_info = self.document_index["documents"][doc_id]
try:
with open(doc_info["path"], 'r') as f:
content = f.read()
return {
"id": doc_id,
"url": doc_info["url"],
"content": content,
"metadata": doc_info["metadata"]
}
except Exception as e:
print(f"检索文档 {doc_id} 时出错: {e}")
return None
def get_document_by_url(self, url: str) -> Optional[Dict]:
"""通过URL查找并检索文档。"""
doc_id = self._generate_doc_id(url)
return self.get_document(doc_id)
def list_documents(self) -> List[Dict]:
"""列出所有存储的文档。"""
return [
{"id": doc_id, "url": info["url"], "metadata": info["metadata"]}
for doc_id, info in self.document_index["documents"].items()
]
4.2 定义代理的工具
创建一个名为 document_agent.py 的文件来实现具有其工具的文档分析代理：
import re
import json
import requests
from datetime import datetime
from typing import List, Dict, Any, Optional
from pydantic import BaseModel, Field
# 从 openai_agents 直接导入 Agent 和 function_tool
from agents import Agent, function_tool
from ollama_client import OllamaClient
from document_memory import DocumentMemory
# 导入代理适配器以向 Agent 类添加 run 方法
import agent_adapter
# 初始化文档内存
document_memory = DocumentMemory()
# 定义工具模式
class FetchDocumentInput(BaseModel):
url: str = Field(..., description="要获取的文档的URL")
class FetchDocumentOutput(BaseModel):
content: str = Field(..., description="文档的内容")
class ExtractInfoInput(BaseModel):
text: str = Field(..., description="从中提取信息的文本")
info_type: str = Field(
..., description="要提取的信息类型（例如，'日期'、'名字'、'关键点'）"
)
class ExtractInfoOutput(BaseModel):
information: List[str] = Field(..., description="提取的信息列表")
class SearchDocumentInput(BaseModel):
text: str = Field(..., description="要在其中搜索的文档文本")
query: str = Field(..., description="要搜索的查询")
class SearchDocumentOutput(BaseModel):
results: List[str] = Field(..., description="匹配段落或句子的列表")
# 实现工具函数
@function_tool
def fetch_document(url: str) -> Dict[str, Any]:
"""从URL获取文档并返回其内容。
首先检查文档内存，然后再进行网络请求。"""
# 检查文档是否已存在于内存中
cached_doc = document_memory.get_document_by_url(url)
if cached_doc:
print(f"从内存中检索文档: {url}")
return {"content": cached_doc["content"]}
# 如果不在内存中，则从URL获取
try:
print(f"从URL获取文档: {url}")
response = requests.get(url)
response.raise_for_status()
content = re.sub(r"<[^>]+>", "", response.text) # 移除HTML标签
# 将文档存储在文档内存中
document_memory.store_document(url, content, {"fetched_at": str(datetime.now())})
return {"content": content}
except Exception as e:
return {"content": f"获取文档时出错: {str(e)}"}
@function_tool
def extract_info(text: str, info_type: str) -> Dict[str, Any]:
"""使用Ollama从文本中提取指定类型的信息。"""
client = OllamaClient(model_name="mistral")
prompt = f"""
从以下文本中提取所有 {info_type}。
仅返回JSON数组。
文本:
{text[:2000]} # 限制文本长度以防止上下文溢出
{info_type.upper()} 的JSON数组:
"""
try:
response = client.chat.completions.create(
model="mistral",
messages=[{"role": "user", "content": prompt}],
temperature=0.1, # 较低的温度以获得更确定的输出
)
result_text = response.choices[0].message.content
print(f"提取信息响应: {result_text[:100]}...")
# 尝试在响应中找到JSON数组
try:
match = re.search(r"\[.*\]", result_text, re.DOTALL)
if match:
information = json.loads(match.group(0))
else:
# 如果找不到JSON数组，则尝试解析整个响应为JSON
try:
information = json.loads(result_text)
if not isinstance(information, list):
information = [result_text.strip()]
except:
information = [result_text.strip()]
except json.JSONDecodeError:
# 如果JSON解析失败，则按逗号或换行符分割
information = []
for line in result_text.split('\n'):
line = line.strip()
if line and not line.startswith('```') and not line.endswith('```'):
information.append(line)
if not information:
information = [item.strip() for item in result_text.split(",")]
except Exception as e:
print(f"提取信息时出错: {str(e)}")
information = [f"提取信息时出错: {str(e)}"]
return {"information": information}
@function_tool
def search_document(text: str, query: str) -> Dict[str, Any]:
"""在文档文本中搜索查询。"""
# 使用正则表达式搜索查询
matches = re.findall(re.escape(query), text, re.IGNORECASE)
# 返回匹配的结果
return {"results": matches}
```搜索文档内容并回答查询问题。
"""
段落 = [p.strip() for p in re.split(r"\n\s*\n", text) if p.strip()]
client = OllamaClient(model_name="mistral")
prompt = f"""
你需要在文档中找到回答或与查询相关的内容：“{query}”
对每个段落与查询的相关性进行评分（0-10分）。
返回最相关的三个段落及其评分，格式为JSON。
文档部分：
{json.dumps(paragraphs[:15])} # 限制为前15个段落以符合上下文限制
输出格式：[{"rating": 8, "text": "段落文本"}, ...]
"""
try:
response = client.chat.completions.create(
model="mistral",
messages=[{"role": "user", "content": prompt}],
temperature=0.1, # 较低的温度以获得更确定的输出
)
result_text = response.choices[0].message.content
print(f"搜索文档响应：{result_text[:100]}...")
# 尝试在响应中找到JSON数组
try:
match = re.search(r"\[.*\]", result_text, re.DOTALL)
if match:
parsed = json.loads(match.group(0))
results = [item["text"] for item in parsed if "text" in item]
else:
# 尝试解析整个响应为JSON
try:
parsed = json.loads(result_text)
if isinstance(parsed, list):
results = [item.get("text", str(item)) for item in parsed]
else:
results = [str(parsed)]
except:
# 如果JSON解析失败，则提取引号中的文本
results = re.findall(r'"([^"]+)"', result_text)
if not results:
results = [result_text]
except json.JSONDecodeError:
# 如果JSON解析完全失败
results = [result_text]
except Exception as e:
print(f"在搜索文档时出错：{str(e)}")
results = [f"在搜索文档时出错：{str(e)}"]
return {"results": results}
# 定义用于文档内存管理的附加工具
class ListDocumentsOutput(BaseModel):
documents: List[Dict] = Field(..., description="存储的文档列表")
class GetDocumentInput(BaseModel):
url: str = Field(..., description="要检索的文档的URL")
class GetDocumentOutput(BaseModel):
content: str = Field(..., description="检索到的文档的内容")
metadata: Dict = Field(..., description="文档的元数据")
@function_tool
def list_documents() -> Dict[str, Any]:
"""列出所有存储在内存中的文档。"""
documents = document_memory.list_documents()
return {"documents": documents}
@function_tool
def get_document(url: str) -> Dict[str, Any]:
"""通过URL从内存中检索文档。"""
doc = document_memory.get_document_by_url(url)
if not doc:
return {"content": "未找到文档", "metadata": {}}
return {"content": doc["content"], "metadata": doc["metadata"]}
# 创建一个文档分析代理
def create_document_agent():
"""创建并返回一个AI代理用于文档分析。"""
client = OllamaClient(model_name="mistral")
# 收集所有带有function_tool装饰器的工具
tools = [
fetch_document,
extract_info,
search_document,
list_documents,
get_document
]
agent = Agent(
name="DocumentAnalysisAgent",
instructions=(
"您是一个文档分析助手，可以帮助用户从文档中提取有价值的信息。\n\n"
"当给出任务时：\n"
"1. 如果需要分析文档，请首先使用fetch_document获取其内容。\n"
"2. 使用extract_info识别文档中的特定信息。\n"
"3. 使用search_document查找特定问题的答案。\n"
"4. 以清晰、有条理的方式总结您的发现。\n\n"
"您可以管理文档：\n"
"- 使用list_documents查看所有已存储的文档\n"
"- 使用get_document检索之前获取的文档\n\n"
"始终要彻底且准确地进行分析。如果文档内容过多，请专注于与用户查询相关的最重要部分。"
),
tools=tools,
model=client,
)
return agent
4.3 整合在一起
让我们在main.py文件中将所有内容整合在一起，并提供一个命令行界面来与我们的文档分析代理交互：
from document_agent import create_document_agent, document_memory
from ollama_client import OllamaClient
def print_banner():
"""打印欢迎横幅，介绍文档分析代理。"""
print("\n" + "="*60)
print("📚 文档分析代理 📚".center(60))
print("="*60)
print("\n此代理可以分析文档、提取信息并搜索内容。")
print("它还具有文档记忆功能，可以在会话之间存储和检索文档。\n")
# 检查现有文档
docs = document_memory.list_documents()
if docs:
print(f"\n🗃️ 已在内存中存储了 {len(docs)} 个文档：")
for i, doc in enumerate(docs, 1):
print(f" {i}. {doc['url']}")
print("\n命令：")
print(" 'exit' - 退出程序")
print(" 'list' - 显示存储的文档")
print(" 'help' - 显示此帮助消息")
print("="*60 + "\n")
def main():
print("正在初始化文档分析代理...")
agent = create_document_agent()
print_banner()
# 调试：测试代理对“什么是战争”的响应
try:
print("\n调试：测试代理对‘什么是战争’的响应")
print("处理中...")
test_response = agent.run(message="什么是战争")
print(f"\n代理（测试）: {test_response.message}")
# 如果使用了工具，显示工具使用信息
if test_response.tool_calls:
print("\n🛠️ 工具使用（测试）：")
for tool in test_response.tool_calls:
# 显示更多关于每个工具调用的信息
inputs = getattr(tool, 'inputs', {})
inputs_str = ', '.join(f"{k}='{v}'" for k, v in inputs.items()) if inputs else ""
print(f" • {tool.name}({inputs_str})")
except Exception as e:
import traceback
print(f"\n调试错误: {str(e)}")
traceback.print_exc()
# 启动对话会话
conversation_id = None
while True:
try:
user_input = input("\n您: ")
if user_input.lower() == 'exit':
break
if user_input.lower() == 'help':
print_banner()
continue
if user_input.lower() == 'list':
docs = document_memory.list_documents()
if not docs:
print("\n目前没有文档存储在内存中。")
else:
print(f"\n📚 内存中的文档 ({len(docs)}):")
for i, doc in enumerate(docs, 1):
metadata = doc.get('metadata', {})
fetched_at = metadata.get('fetched_at', '未知时间')
print(f" {i}. {doc['url']} (获取时间: {fetched_at})")
continue
# 获取代理响应
print("\n处理中...")
response = agent.run(
message=user_input,
conversation_id=conversation_id
)
# 存储对话ID以保持连续性
conversation_id = response.conversation_id
# 打印响应
print(f"\n代理: {response.message}")
# 如果使用了工具，显示工具使用信息
if response.tool_calls:
print("\n🛠️ 工具使用：")
for tool in response.tool_calls:
# 显示更多关于每个工具调用的信息
inputs = getattr(tool, 'inputs', {})
inputs_str = ', '.join(f"{k}='{v}'" for k, v in inputs.items()) if inputs else ""
print(f" • {tool.name}({inputs_str})")
except KeyboardInterrupt:
print("\n退出中...")
break
except Exception as e:
import traceback
print(f"\n错误: {str(e)}")
traceback.print_exc()
if __name__ == "__main__":
main()
4.4 示例对话
以下是一个与文档分析代理的对话示例：
==========================================
📚 文档分析代理 📚
==========================================
此代理可以分析文档、提取信息并搜索内容。
它还具有文档记忆功能，可以在会话之间存储和检索文档。
命令：
'exit' - 退出程序
'list' - 显示存储的文档
'help' - 显示此帮助消息
==========================================
您: 请分析https://en.wikipedia.org/wiki/Artificial_intelligence上的文章，并告诉我人工智能的概念首次出现是什么时候。
处理中...
代理: 根据我对维基百科上人工智能文章的分析，人工智能概念的历史根源可以追溯到几个世纪以前，但作为学术领域的正式人工智能是在1956年成立的。
根据文章，达特茅斯学院夏季研讨会被认为是人工智能作为一个领域成立的标志性事件。这是约翰·麦卡锡首次提出“人工智能”一词的达特茅斯会议。
然而, 人工智能概念的出现可以追溯到更早的历史时期：
- 古希腊神话中提到了被设计用来模仿人类功能的机械人
- 哲学家亚里士多德在三段论中描述了机械推理
- 13世纪，拉蒙·柳尔（Ramon Llull）开发了逻辑机器
- 17世纪，勒内·笛卡尔（René Descartes）、托马斯·霍布斯（Thomas Hobbes）和戈特弗里德·莱布尼茨（Gottfried Leibniz）探讨了机械推理
- 19世纪，查尔斯·巴贝奇（Charles Babbage）和阿达·洛夫莱斯（Ada Lovelace）考虑了可编程的机械计算设备
文章指出，现代人工智能研究领域正式始于1956年由约翰·麦卡锡（John McCarthy）、马文·明斯基（Marvin Minsky）、克劳德·香农（Claude Shannon）和纳撒尼尔·罗切斯特（Nathaniel Rochester）组织的工作坊。
🛠️ 工具使用：
• fetch_document(url='https://en.wikipedia.org/wiki/Artificial_intelligence')
• search_document(query='when was AI first developed concept history')
• extract_info(info_type='key dates in AI history')
5、故障排除
这里有一些你可能会遇到的问题以及解决方法：
5.1 模型问题
问题：模型生成的响应质量差、产生幻觉或无法正确使用工具。
解决方案：
- 尝试更强大的模型，如
llama3或mixtral - 检查提示是否清晰且格式良好
- 减少工具的复杂性
- 在代理的系统提示中添加更多明确的指令
你可以通过以下方式获取更强大的模型：
ollama pull llama3
然后更新客户端：
client = OllamaClient(model_name="llama3")
5.2 上下文长度问题
问题：模型返回不完整的响应或处理长文档时失败。
解决方案：
- 实现文档文本的分块（我们已经在工具中限制为2000个字符）
- 使用具有更大上下文窗口的模型（如Llama 3或Mixtral）
- 将复杂任务分解为较小的子任务
5.3 API兼容性问题
问题：某些OpenAI客户端功能不受Ollama支持。
解决方案：
- 我们的适配器客户端处理了最常见的方法差异
- 如果遇到不支持的功能，请向OllamaClient类添加类似的包装方法
- 查看Ollama的API文档以获取兼容的端点
6、结束语
在这篇指南中，我们探索了如何将OpenAI Agents SDK与Ollama集成，创建一个功能强大的本地基础设施运行的文档分析代理。这种方法结合了OpenAI结构化代理框架的优势和Ollama本地推理的隐私和成本效益。
主要收获：
架构：我们构建了一个分层架构：
- Ollama提供LLM推理能力
- 自定义客户端适配器连接Ollama与OpenAI接口
- OpenAI Agents SDK提供代理框架
- 自定义工具用于文档分析和记忆
实现：我们构建了一个完整的文档分析代理：
- 文档获取和解析
- 信息提取
- 文档搜索
- 持久化文档存储
优势：
- 完全的数据隐私
- 无持续API成本
- 可定制于特定用例
- 离线工作
局限性和缓解措施：
- 模型质量限制（通过使用更强大的模型缓解）
- 上下文长度约束（通过我们的分块方法缓解）
- API兼容性差距（通过自定义客户端缓解）
这种集成展示了组织如何在保持数据和基础设施控制的同时利用先进AI代理框架的力量。结果是一个灵活、可扩展的系统，可以适应许多不同的用例，而不仅仅是文档分析。
在此基础上，你可以为各种领域创建专业代理，同时保持所有处理的本地性和安全性。
原文链接：Complete Guide Integrating OpenAI Agents SDK with Ollama
汇智网翻译整理，转载请标明出处