Zum Hauptinhalt springen

/mcp[BETA]- Model Context Protocol

MCP-Tools auf LiteLLM Proxy Server bereitstellen​

Dies ermöglicht es Ihnen, Tools zu definieren, die von jedem MCP-kompatiblen Client aufgerufen werden können. Definieren Sie Ihre mcp_servers mit LiteLLM und alle Ihre Clients können verfügbare Tools auflisten und aufrufen.

LiteLLM MCP Architektur: MCP-Tools mit allen von LiteLLM unterstützten Modellen verwenden

Wie es funktioniert​

LiteLLM stellt die folgenden MCP-Endpunkte bereit

  • /mcp/tools/list - Alle verfügbaren Tools auflisten
  • /mcp/tools/call - Ein bestimmtes Tool mit den bereitgestellten Argumenten aufrufen

Wenn sich MCP-Clients mit LiteLLM verbinden, können sie diesem Workflow folgen

  1. Verbinden Sie sich mit dem LiteLLM MCP Server
  2. Alle auf LiteLLM verfügbaren Tools auflisten
  3. Client führt LLM-API-Anfrage mit Tool-Aufruf(en) durch
  4. LLM-API gibt zurück, welche Tools aufgerufen werden sollen und mit welchen Argumenten
  5. MCP-Client führt MCP-Tool-Aufrufe an LiteLLM durch
  6. LiteLLM führt die Tool-Aufrufe an den entsprechenden MCP-Server durch
  7. LiteLLM gibt die Ergebnisse der Tool-Aufrufe an den MCP-Client zurück

Verwendung​

1. Definieren Sie Ihre Tools unter mcp_servers in Ihrer config.yaml-Datei.​

LiteLLM ermöglicht es Ihnen, Ihre Tools im Abschnitt mcp_servers Ihrer config.yaml-Datei zu definieren. Alle hier aufgeführten Tools sind für MCP-Clients verfügbar (wenn sie sich mit LiteLLM verbinden und list_tools aufrufen).

config.yaml
model_list:
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: sk-xxxxxxx

mcp_servers:
  zapier_mcp:
    url: "https://actions.zapier.com/mcp/sk-akxxxxx/sse"
  fetch:
    url: "https://:8000/sse"

2. LiteLLM Gateway starten​

Docker-Ausführung
docker run -d \
  -p 4000:4000 \
  -e OPENAI_API_KEY=$OPENAI_API_KEY \
  --name my-app \
  -v $(pwd)/my_config.yaml:/app/config.yaml \
  my-app:latest \
  --config /app/config.yaml \
  --port 4000 \
  --detailed_debug \

3. Führen Sie eine LLM-API-Anfrage aus​

In diesem Beispiel werden wir Folgendes tun

  1. Verwenden Sie den MCP-Client, um MCP-Tools auf dem LiteLLM Proxy aufzulisten
  2. Verwenden Sie transform_mcp_tool_to_openai_tool, um MCP-Tools in OpenAI-Tools zu konvertieren
  3. Stellen Sie die MCP-Tools für gpt-4o bereit
  4. Behandeln Sie den Tool-Aufruf von gpt-4o
  5. Konvertieren Sie den OpenAI-Tool-Aufruf in einen MCP-Tool-Aufruf
  6. Führen Sie den Tool-Aufruf auf dem MCP-Server aus
MCP-Client-Tools auflisten
import asyncio
from openai import AsyncOpenAI
from openai.types.chat import ChatCompletionUserMessageParam
from mcp import ClientSession
from mcp.client.sse import sse_client
from litellm.experimental_mcp_client.tools import (
    transform_mcp_tool_to_openai_tool,
    transform_openai_tool_call_request_to_mcp_tool_call_request,
)


async def main():
    # Initialize clients
    
    # point OpenAI client to LiteLLM Proxy
    client = AsyncOpenAI(api_key="sk-1234", base_url="https://:4000")

    # Point MCP client to LiteLLM Proxy
    async with sse_client("https://:4000/mcp/") as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # 1. List MCP tools on LiteLLM Proxy
            mcp_tools = await session.list_tools()
            print("List of MCP tools for MCP server:", mcp_tools.tools)

            # Create message
            messages = [
                ChatCompletionUserMessageParam(
                    content="Send an email about LiteLLM supporting MCP", role="user"
                )
            ]

            # 2. Use `transform_mcp_tool_to_openai_tool` to convert MCP tools to OpenAI tools
            # Since OpenAI only supports tools in the OpenAI format, we need to convert the MCP tools to the OpenAI format.
            openai_tools = [
                transform_mcp_tool_to_openai_tool(tool) for tool in mcp_tools.tools
            ]

            # 3. Provide the MCP tools to `gpt-4o`
            response = await client.chat.completions.create(
                model="gpt-4o",
                messages=messages,
                tools=openai_tools,
                tool_choice="auto",
            )

            # 4. Handle tool call from `gpt-4o`
            if response.choices[0].message.tool_calls:
                tool_call = response.choices[0].message.tool_calls[0]
                if tool_call:

                    # 5. Convert OpenAI tool call to MCP tool call
                    # Since MCP servers expect tools in the MCP format, we need to convert the OpenAI tool call to the MCP format.
                    # This is done using litellm.experimental_mcp_client.tools.transform_openai_tool_call_request_to_mcp_tool_call_request
                    mcp_call = (
                        transform_openai_tool_call_request_to_mcp_tool_call_request(
                            openai_tool=tool_call.model_dump()
                        )
                    )

                    # 6. Execute tool call on MCP server
                    result = await session.call_tool(
                        name=mcp_call.name, arguments=mcp_call.arguments
                    )

                    print("Result:", result)


# Run it
asyncio.run(main())

LiteLLM Python SDK MCP-Bridge​

Das LiteLLM Python SDK fungiert als MCP-Bridge, um MCP-Tools mit allen von LiteLLM unterstützten Modellen zu nutzen. LiteLLM bietet die folgenden Funktionen für die Verwendung von MCP

  • Auflisten von verfügbaren MCP-Tools: OpenAI-Clients können alle verfügbaren MCP-Tools anzeigen
    • litellm.experimental_mcp_client.load_mcp_tools, um alle verfügbaren MCP-Tools aufzulisten
  • Aufrufen von MCP-Tools: OpenAI-Clients können MCP-Tools aufrufen
    • litellm.experimental_mcp_client.call_openai_tool, um ein OpenAI-Tool auf einem MCP-Server aufzurufen

1. Verfügbare MCP-Tools auflisten​

In diesem Beispiel verwenden wir litellm.experimental_mcp_client.load_mcp_tools, um alle verfügbaren MCP-Tools auf jedem MCP-Server aufzulisten. Diese Methode kann auf zwei Arten verwendet werden

  • format="mcp" - (Standard) MCP-Tools zurückgeben
    • Gibt zurück: mcp.types.Tool
  • format="openai" - MCP-Tools konvertiert in für die OpenAI API kompatible Tools zurückgeben. Ermöglicht die Verwendung mit OpenAI-Endpunkten.
    • Gibt zurück: openai.types.chat.ChatCompletionToolParam
MCP-Client-Tools auflisten
# Create server parameters for stdio connection
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
import os
import litellm
from litellm import experimental_mcp_client


server_params = StdioServerParameters(
    command="python3",
    # Make sure to update to the full absolute path to your mcp_server.py file
    args=["./mcp_server.py"],
)

async with stdio_client(server_params) as (read, write):
    async with ClientSession(read, write) as session:
        # Initialize the connection
        await session.initialize()

        # Get tools
        tools = await experimental_mcp_client.load_mcp_tools(session=session, format="openai")
        print("MCP TOOLS: ", tools)

        messages = [{"role": "user", "content": "what's (3 + 5)"}]
        llm_response = await litellm.acompletion(
            model="gpt-4o",
            api_key=os.getenv("OPENAI_API_KEY"),
            messages=messages,
            tools=tools,
        )
        print("LLM RESPONSE: ", json.dumps(llm_response, indent=4, default=str))

2. MCP-Tools auflisten und aufrufen​

In diesem Beispiel werden wir verwenden

  • litellm.experimental_mcp_client.load_mcp_tools, um alle verfügbaren MCP-Tools auf jedem MCP-Server aufzulisten
  • litellm.experimental_mcp_client.call_openai_tool, um ein OpenAI-Tool auf einem MCP-Server aufzurufen

Die erste LLM-Antwort gibt eine Liste von OpenAI-Tools zurück. Wir nehmen den ersten Tool-Aufruf aus der LLM-Antwort und übergeben ihn an litellm.experimental_mcp_client.call_openai_tool, um das Tool auf dem MCP-Server aufzurufen.

Wie litellm.experimental_mcp_client.call_openai_tool funktioniert​

  • Akzeptiert einen OpenAI-Tool-Aufruf aus der LLM-Antwort
  • Konvertiert den OpenAI-Tool-Aufruf in ein MCP-Tool
  • Ruft das MCP-Tool auf dem MCP-Server auf
  • Gibt das Ergebnis des MCP-Tool-Aufrufs zurück
MCP-Client: Tools auflisten und aufrufen
# Create server parameters for stdio connection
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
import os
import litellm
from litellm import experimental_mcp_client


server_params = StdioServerParameters(
    command="python3",
    # Make sure to update to the full absolute path to your mcp_server.py file
    args=["./mcp_server.py"],
)

async with stdio_client(server_params) as (read, write):
    async with ClientSession(read, write) as session:
        # Initialize the connection
        await session.initialize()

        # Get tools
        tools = await experimental_mcp_client.load_mcp_tools(session=session, format="openai")
        print("MCP TOOLS: ", tools)

        messages = [{"role": "user", "content": "what's (3 + 5)"}]
        llm_response = await litellm.acompletion(
            model="gpt-4o",
            api_key=os.getenv("OPENAI_API_KEY"),
            messages=messages,
            tools=tools,
        )
        print("LLM RESPONSE: ", json.dumps(llm_response, indent=4, default=str))

        openai_tool = llm_response["choices"][0]["message"]["tool_calls"][0]
        # Call the tool using MCP client
        call_result = await experimental_mcp_client.call_openai_tool(
            session=session,
            openai_tool=openai_tool,
        )
        print("MCP TOOL CALL RESULT: ", call_result)

        # send the tool result to the LLM
        messages.append(llm_response["choices"][0]["message"])
        messages.append(
            {
                "role": "tool",
                "content": str(call_result.content[0].text),
                "tool_call_id": openai_tool["id"],
            }
        )
        print("final messages with tool result: ", messages)
        llm_response = await litellm.acompletion(
            model="gpt-4o",
            api_key=os.getenv("OPENAI_API_KEY"),
            messages=messages,
            tools=tools,
        )
        print(
            "FINAL LLM RESPONSE: ", json.dumps(llm_response, indent=4, default=str)
        )

Berechtigungsverwaltung​

Derzeit können alle virtuellen Schlüssel auf die MCP-Endpunkte zugreifen. Wir arbeiten an einer Funktion, um den MCP-Zugriff nach Schlüsseln/Teams/Benutzern/Organisationen einzuschränken.

Diskutieren Sie mit hier