Ein MCP-gestützter Agent in ~70 Zeilen Code

Hugging Face hat das Design von Tiny Agents auf Python ausgeweitet und nutzt das Model Context Protocol (MCP), um die Integration von Tools für große Sprachmodelle (LLMs) zu optimieren.

Einführung

In der heutigen Zeit, in der Künstliche Intelligenz (KI) und maschinelles Lernen immer mehr an Bedeutung gewinnen, ist die Fähigkeit, verschiedene Tools und APIs nahtlos zu integrieren, entscheidend. Hugging Face hat mit dem MCP eine offene Protokollstandardisierung entwickelt, die es LLMs ermöglicht, effizient mit externen Tools zu interagieren. Dies reduziert den Aufwand für die Erstellung benutzerdefinierter Integrationen und erleichtert das Hinzufügen neuer Funktionen zu LLMs.

Wie man mit einem Tiny Agent in Python beginnt

In diesem Artikel zeigen wir Ihnen, wie Sie einen Tiny Agent in Python einrichten, der mit MCP-Servern verbunden ist, um leistungsstarke Tool-Funktionen freizuschalten. Sie werden sehen, wie einfach es ist, Ihren eigenen Agenten zu erstellen und mit ihm zu arbeiten!

Demo ausführen

Um einen Agenten auszuführen, müssen Sie zunächst die neueste Version von huggingface_hub mit der Option mcp installieren:

pip install "huggingface_hub[mcp]>=0.32.0"

Jetzt können Sie einen Agenten über die Kommandozeile ausführen. Sie können Agenten direkt aus dem Hugging Face Hub laden oder einen Pfad zu Ihrer eigenen lokalen Agenten-Konfiguration angeben:

tiny-agents run --help

Agenten-Konfiguration

Das Verhalten jedes Agenten wird durch eine agent.json-Datei definiert. Diese Datei enthält Informationen über das verwendete Modell, den Inferenzanbieter und die MCP-Server, mit denen der Agent verbunden ist. Hier ist ein Beispiel für eine agent.json-Datei:

{
  "model": "Qwen/Qwen2.5-72B-Instruct",
  "provider": "nebius",
  "servers": [
    {
      "type": "stdio",
      "config": {
        "command": "npx",
        "args": ["@playwright/mcp@latest"]
      }
    }
  ]
}

Verwendung von Tools

Moderne LLMs sind für die Verwendung von Funktionen (oder Tools) ausgelegt, was es Benutzern ermöglicht, Anwendungen zu erstellen, die auf spezifische Anwendungsfälle und reale Aufgaben zugeschnitten sind. Ein Beispiel für ein Tool könnte die Abfrage von Wetterdaten sein:

tools = [
  {
    "type": "function",
    "function": {
      "name": "get_weather",
      "description": "Aktuelle Temperatur für einen bestimmten Ort abrufen.",
      "parameters": {
        "type": "object",
        "properties": {
          "location": {
            "type": "string",
            "description": "Stadt und Land, z.B. Paris, Frankreich"
          }
        },
        "required": ["location"]
      }
    }
  }
]

Der MCPClient

Der MCPClient ist das Herzstück der Tool-Nutzungsfunktionalität. Er verwaltet asynchrone Verbindungen zu einem oder mehreren MCP-Servern, entdeckt Tools von diesen Servern und formatiert diese für das LLM. Hier ist ein Blick auf die Methode, die eine Verbindung zu einem MCP-Server herstellt:

async def add_mcp_server(self, type: ServerType, **params: Any):
  # Verbindung basierend auf dem Typ herstellen
  # ...

Die Agentenklasse

Die Agentenklasse ist einfach und konzentriert sich auf die Verwaltung der Konversation. Sie erbt vom MCPClient und fügt die Logik zur Verwaltung der Konversation hinzu. Hier ist ein Beispiel für die Initialisierung eines Agenten:

class Agent(MCPClient):
  def __init__(self, *, model: str, servers: Iterable[Dict], ...):
    super().__init__(model=model, ...)
    self.messages: List[Union[Dict, ChatCompletionInputMessage]] = [
      {"role": "system", "content": prompt or DEFAULT_SYSTEM_PROMPT}
    ]

Nächste Schritte

Es gibt viele Möglichkeiten, den MCP-Client und den Tiny Agent weiter zu erkunden und auszubauen. Hier sind einige Ideen, um Ihnen den Einstieg zu erleichtern:

• Benchmarking, wie verschiedene LLM-Modelle und Inferenzanbieter die Leistung des Agenten beeinflussen.
• Führen Sie Tiny Agents mit lokalen LLM-Inferenzservern aus.
• Teilen Sie Ihre einzigartigen Tiny Agents und öffnen Sie PRs im tiny-agents Dataset auf dem Hugging Face Hub.

Fazit

Die Entwicklung eines MCP-gestützten Agenten in Python ist ein spannender Schritt in der Welt der KI. Mit nur wenigen Zeilen Code können Sie leistungsstarke Tools nutzen und Ihre eigenen Agenten erstellen, die auf Ihre spezifischen Bedürfnisse zugeschnitten sind.

Quellenliste:

• Quelle: Tiny Agents in Python: An MCP-Powered Agent in ~70 Lines of Code
• Hugging Face Inference Providers
• Hugging Face Hub