工具和函数调用

import json, requests
from openai import OpenAI

OPENROUTE_API_KEY = f"{YOUR_API_KEY}"

# 您可以使用任何支持工具调用的模型
MODEL = "google/gemini-2.0-flash-001"

openai_client = OpenAI(
  base_url="https://openroute.cn/api/v1",
  api_key=OPENROUTE_API_KEY,
)

task = "詹姆斯·乔伊斯的一些书籍标题是什么？"

messages = [
  {
    "role": "system",
    "content": "您是一个有用的助手。"
  },
  {
    "role": "user",
    "content": task,
  }
]

const response = await fetch('https://openroute.cn/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    Authorization: `Bearer {YOUR_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'google/gemini-2.0-flash-001',
    messages: [
      { role: 'system', content: '您是一个有用的助手。' },
      {
        role: 'user',
        content: '詹姆斯·乔伊斯的一些书籍标题是什么？',
      },
    ],
  }),
});

def search_gutenberg_books(search_terms):
    search_query = " ".join(search_terms)
    url = "https://gutendex.com/books"
    response = requests.get(url, params={"search": search_query})

    simplified_results = []
    for book in response.json().get("results", []):
        simplified_results.append({
            "id": book.get("id"),
            "title": book.get("title"),
            "authors": book.get("authors")
        })

    return simplified_results

tools = [
  {
    "type": "function",
    "function": {
      "name": "search_gutenberg_books",
      "description": "根据指定的搜索词在古腾堡项目图书馆中搜索书籍",
      "parameters": {
        "type": "object",
        "properties": {
          "search_terms": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "在古腾堡图书馆中查找书籍的搜索词列表（例如 ['dickens', 'great'] 搜索狄更斯的标题中包含 'great' 的书籍）"
          }
        },
        "required": ["search_terms"]
      }
    }
  }
]

TOOL_MAPPING = {
    "search_gutenberg_books": search_gutenberg_books
}

async function searchGutenbergBooks(searchTerms: string[]): Promise<Book[]> {
  const searchQuery = searchTerms.join(' ');
  const url = 'https://gutendex.com/books';
  const response = await fetch(`${url}?search=${searchQuery}`);
  const data = await response.json();

  return data.results.map((book: any) => ({
    id: book.id,
    title: book.title,
    authors: book.authors,
  }));
}

const tools = [
  {
    type: 'function',
    function: {
      name: 'searchGutenbergBooks',
      description:
        '根据指定的搜索词在古腾堡项目图书馆中搜索书籍',
      parameters: {
        type: 'object',
        properties: {
          search_terms: {
            type: 'array',
            items: {
              type: 'string',
            },
            description:
              "在古腾堡图书馆中查找书籍的搜索词列表（例如 ['dickens', 'great'] 搜索狄更斯的标题中包含 'great' 的书籍）",
          },
        },
        required: ['search_terms'],
      },
    },
  },
];

const TOOL_MAPPING = {
  searchGutenbergBooks,
};

request_1 = {
    "model": google/gemini-2.0-flash-001,
    "tools": tools,
    "messages": messages
}

response_1 = openai_client.chat.completions.create(**request_1).message

const request_1 = await fetch('https://openroute.cn/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    Authorization: `Bearer {YOUR_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'google/gemini-2.0-flash-001',
    tools,
    messages,
  }),
});

const data = await request_1.json();
const response_1 = data.choices[0].message;

# 将响应附加到消息数组，以便 LLM 具有完整上下文
# 很容易忘记这一步！
messages.append(response_1)

# 现在我们处理请求的工具调用，并使用我们的书籍查找工具
for tool_call in response_1.tool_calls:
    '''
    在这种情况下，我们只提供了一个工具，所以我们知道要调用什么函数。
    当提供多个工具时，您可以检查 `tool_call.function.name`
    来找出您需要在本地调用什么函数。
    '''
    tool_name = tool_call.function.name
    tool_args = json.loads(tool_call.function.arguments)
    tool_response = TOOL_MAPPING[tool_name](**tool_args)
    messages.append({
      "role": "tool",
      "tool_call_id": tool_call.id,
      "content": json.dumps(tool_response),
    })

// Append the response to the messages array so the LLM has the full context
// It's easy to forget this step!
messages.push(response_1);

// Now we process the requested tool calls, and use our book lookup tool
for (const toolCall of response_1.tool_calls) {
  const toolName = toolCall.function.name;
  const { search_params } = JSON.parse(toolCall.function.arguments);
  const toolResponse = await TOOL_MAPPING[toolName](search_params);
  messages.push({
    role: 'tool',
    toolCallId: toolCall.id,
    name: toolName,
    content: JSON.stringify(toolResponse),
  });
}

request_2 = {
  "model": MODEL,
  "messages": messages,
  "tools": tools
}

response_2 = openai_client.chat.completions.create(**request_2)

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

const response = await fetch('https://openroute.cn/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    Authorization: `Bearer {YOUR_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'google/gemini-2.0-flash-001',
    messages,
    tools,
  }),
});

const data = await response.json();
console.log(data.choices[0].message.content);

def call_llm(msgs):
    resp = openai_client.chat.completions.create(
        model=google/gemini-2.0-flash-001,
        tools=tools,
        messages=msgs
    )
    msgs.append(resp.choices[0].message.dict())
    return resp

def get_tool_response(response):
    tool_call = response.choices[0].message.tool_calls[0]
    tool_name = tool_call.function.name
    tool_args = json.loads(tool_call.function.arguments)

    # Look up the correct tool locally, and call it with the provided arguments
    # Other tools can be added without changing the agentic loop
    tool_result = TOOL_MAPPING[tool_name](**tool_args)

    return {
        "role": "tool",
        "tool_call_id": tool_call.id,
        "content": tool_result,
    }

max_iterations = 10
iteration_count = 0

while iteration_count < max_iterations:
    iteration_count += 1
    resp = call_llm(_messages)

    if resp.choices[0].message.tool_calls is not None:
        messages.append(get_tool_response(resp))
    else:
        break

if iteration_count >= max_iterations:
    print("Warning: Maximum iterations reached")

print(messages[-1]['content'])

async function callLLM(messages: Message[]): Promise<Message> {
  const response = await fetch(
    'https://openroute.cn/api/v1/chat/completions',
    {
      method: 'POST',
      headers: {
        Authorization: `Bearer {YOUR_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        model: 'google/gemini-2.0-flash-001',
        tools,
        messages,
      }),
    },
  );

  const data = await response.json();
  messages.push(data.choices[0].message);
  return data;
}

async function getToolResponse(response: Message): Promise<Message> {
  const toolCall = response.toolCalls[0];
  const toolName = toolCall.function.name;
  const toolArgs = JSON.parse(toolCall.function.arguments);

  // Look up the correct tool locally, and call it with the provided arguments
  // Other tools can be added without changing the agentic loop
  const toolResult = await TOOL_MAPPING[toolName](toolArgs);

  return {
    role: 'tool',
    toolCallId: toolCall.id,
    content: toolResult,
  };
}

const maxIterations = 10;
let iterationCount = 0;

while (iterationCount < maxIterations) {
  iterationCount++;
  const response = await callLLM(messages);

  if (response.toolCalls) {
    messages.push(await getToolResponse(response));
  } else {
    break;
  }
}

if (iterationCount >= maxIterations) {
  console.warn("Warning: Maximum iterations reached");
}

console.log(messages[messages.length - 1].content);