--- id: a1fad13de24c90924cfa9e25e9f986cb author: snowmerak title: MCP-Host etwas genauer verstehen description: Dieser Beitrag soll das Verständnis des MCP-Protokolls von Anthropic und des in Go implementierten MCP-Hosts (mcphost) erleichtern. language: de date: 2025-04-08T00:59:42.416582136Z path: /blog/posts/a-little-understanding-of-mcp-host-zb952aae0 category: ai --- ## Was ist MCP [MCP](https://modelcontextprotocol.io/introduction) ist ein von Anthropic für Claude entwickeltes Protokoll. MCP ist die Abkürzung für Model Context Protocol und ermöglicht es einem LLM, aktiv Aktionen oder Ressourcen von außen anzufordern. Da MCP wortwörtlich nur ein Protokoll ist, das Anfragen und Antworten übermittelt, müssen der Ablauf und die Ausführung vom Entwickler selbst implementiert werden. ### Zum internen Ablauf Bevor der interne Ablauf erläutert wird, soll kurz auf [Gemini Function Calling](https://ai.google.dev/gemini-api/docs/function-calling) eingegangen werden. Gemini Function Calling ermöglicht ebenso wie MCP, dass ein LLM externe Aktionen eigenständig aufrufen kann. Man mag sich nun fragen, warum Function Calling überhaupt herangezogen wird. Der Grund liegt darin, dass Function Calling früher als MCP erschienen ist und beide auf dem OpenAPI-Schema basieren, weshalb sie kompatibel sind und sich ihr Verhalten vermutlich ähnelt. Da die Beschreibung von Gemini Function Calling vergleichsweise ausführlich ist, dürfte sie hilfreich sein, weshalb sie hier herangezogen wird. ![FunctionCalling](/assets/images/mcp_with_csharp/function-calling-overview.png) Der Gesamtablauf sieht wie folgt aus: 1. Die Funktion wird definiert. 2. Die Funktionsdefinition wird zusammen mit dem Prompt an Gemini gesendet. 1. "Send user prompt along with the function declaration(s) to the model. It analyzes the request and determines if a function call would be helpful. If so, it responds with a structured JSON object." 3. Gemini fordert bei Bedarf einen Funktionsaufruf an. 1. Wenn Gemini es für nötig hält, erhält der Aufrufer den Namen und die Parameter für den Funktionsaufruf. 2. Der Aufrufer kann entscheiden, ob er die Ausführung durchführt oder nicht. 1. Die Funktion aufrufen und einen gültigen Wert zurückgeben 2. Die Funktion nicht aufrufen, sondern Daten so zurückgeben, als wäre sie aufgerufen worden 3. Den Aufruf einfach ignorieren 4. Gemini fordert im obigen Ablauf mehrere Funktionen gleichzeitig an oder führt Aktionen aus und fordert nach Prüfung des Ergebnisses erneut Aufrufe an. 5. Sobald eine geordnete Antwort vorliegt, endet der Ablauf. Dieser Ablauf stimmt im Allgemeinen mit MCP überein. Dies wird auch im [MCP-Tutorial](https://modelcontextprotocol.io/tutorials/building-mcp-with-llms) ähnlich beschrieben. Auch ollama tools verhält sich ähnlich. Und erfreulicherweise weisen diese drei Werkzeuge, ollama tools, MCP und Gemini Function Calling, eine nahezu gemeinsame Schemastruktur auf, sodass man durch die Implementierung von MCP allein alle drei nutzen kann. Ein Nachteil, den alle teilen, sei noch erwähnt: Da das Modell die Ausführung letztlich selbst steuert, kann es bei einem schlechten Modellzustand zu Fehlverhalten kommen, etwa indem Funktionen nicht aufgerufen werden, falsch aufgerufen werden oder der MCP-Server mit Anfragen überflutet wird (DoS). ## MCP-Host in Go ### mark3lab's mcphost In Go gibt es [mcphost](https://github.com/mark3labs/mcphost), das von der Organisation mark3lab entwickelt wird. Die Verwendung ist sehr einfach. ```sh go install github.com/mark3labs/mcphost@latest ``` Nach der Installation erstellt man die Datei `$HOME/.mcp.json` und schreibt Folgendes hinein: ```json { "mcpServers": { "sqlite": { "command": "uvx", "args": [ "mcp-server-sqlite", "--db-path", "/tmp/foo.db" ] }, "filesystem": { "command": "npx", "args": [ "-y", "@modelcontextprotocol/server-filesystem", "/tmp" ] } } } ``` Anschließend führt man es mit einem ollama-Modell wie folgt aus. Falls erforderlich, lädt man zuvor das Modell mit `ollama pull mistral-small` herunter. > Grundsätzlich werden Claude oder qwen2.5 empfohlen, ich persönlich empfehle derzeit jedoch mistral-small. ```sh mcphost -m ollama:mistral-small ``` Bei dieser Ausführung kann man das System jedoch nur im CLI-Modus als Frage-Antwort-System verwenden. Daher werden wir den Code von `mcphost` so anpassen, dass er sich programmierbarer verhält. ### Fork von mcphost Wie bereits gesehen, enthält `mcphost` die Funktion, Metadaten über MCP zu extrahieren und Funktionen aufzurufen. Daher werden ein Teil zum Aufruf des LLM, ein Teil zur Verwaltung der MCP-Server und ein Teil zur Verwaltung des Nachrichtenverlaufs benötigt. Der entsprechende Teil wurde im folgenden Paket als `Runner` übernommen. ```go package runner import ( "context" "encoding/json" "fmt" "log" "strings" "time" mcpclient "github.com/mark3labs/mcp-go/client" "github.com/mark3labs/mcp-go/mcp" "github.com/mark3labs/mcphost/pkg/history" "github.com/mark3labs/mcphost/pkg/llm" ) type Runner struct { provider llm.Provider mcpClients map[string]*mcpclient.StdioMCPClient tools []llm.Tool messages []history.HistoryMessage } ``` Auf die interne Deklaration dieses Teils gehe ich nicht näher ein. Sie entspricht jedoch größtenteils ihrem Namen. ```go func NewRunner(systemPrompt string, provider llm.Provider, mcpClients map[string]*mcpclient.StdioMCPClient, tools []llm.Tool) *Runner { return &Runner{ provider: provider, mcpClients: mcpClients, tools: tools, messages: []history.HistoryMessage{ { Role: "system", Content: []history.ContentBlock{{ Type: "text", Text: systemPrompt, }}, }, }, } } ``` Zu den hier verwendeten `mcpClients` und `tools` siehe bitte [diese Datei](https://github.com/snowmerak/mcphost/blob/main/internal/runner/from.go). Für `provider` verwenden wir den von ollama, siehe bitte [diese Datei](https://github.com/snowmerak/mcphost/blob/main/pkg/llm/ollama/provider.go). Das Hauptgericht ist die Methode `Run`. ```go func (r *Runner) Run(ctx context.Context, prompt string) (string, error) { if len(prompt) != 0 { r.messages = append(r.messages, history.HistoryMessage{ Role: "user", Content: []history.ContentBlock{{ Type: "text", Text: prompt, }}, }) } llmMessages := make([]llm.Message, len(r.messages)) for i := range r.messages { llmMessages[i] = &r.messages[i] } const initialBackoff = 1 * time.Second const maxRetries int = 5 const maxBackoff = 30 * time.Second var message llm.Message var err error backoff := initialBackoff retries := 0 for { message, err = r.provider.CreateMessage( context.Background(), prompt, llmMessages, r.tools, ) if err != nil { if strings.Contains(err.Error(), "overloaded_error") { if retries >= maxRetries { return "", fmt.Errorf( "claude is currently overloaded. please wait a few minutes and try again", ) } time.Sleep(backoff) backoff *= 2 if backoff > maxBackoff { backoff = maxBackoff } retries++ continue } return "", err } break } var messageContent []history.ContentBlock var toolResults []history.ContentBlock messageContent = []history.ContentBlock{} if message.GetContent() != "" { messageContent = append(messageContent, history.ContentBlock{ Type: "text", Text: message.GetContent(), }) } for _, toolCall := range message.GetToolCalls() { input, _ := json.Marshal(toolCall.GetArguments()) messageContent = append(messageContent, history.ContentBlock{ Type: "tool_use", ID: toolCall.GetID(), Name: toolCall.GetName(), Input: input, }) parts := strings.Split(toolCall.GetName(), "__") serverName, toolName := parts[0], parts[1] mcpClient, ok := r.mcpClients[serverName] if !ok { continue } var toolArgs map[string]interface{} if err := json.Unmarshal(input, &toolArgs); err != nil { continue } var toolResultPtr *mcp.CallToolResult req := mcp.CallToolRequest{} req.Params.Name = toolName req.Params.Arguments = toolArgs toolResultPtr, err = mcpClient.CallTool( context.Background(), req, ) if err != nil { errMsg := fmt.Sprintf( "Error calling tool %s: %v", toolName, err, ) log.Printf("Error calling tool %s: %v", toolName, err) toolResults = append(toolResults, history.ContentBlock{ Type: "tool_result", ToolUseID: toolCall.GetID(), Content: []history.ContentBlock{{ Type: "text", Text: errMsg, }}, }) continue } toolResult := *toolResultPtr if toolResult.Content != nil { resultBlock := history.ContentBlock{ Type: "tool_result", ToolUseID: toolCall.GetID(), Content: toolResult.Content, } var resultText string for _, item := range toolResult.Content { if contentMap, ok := item.(map[string]interface{}); ok { if text, ok := contentMap["text"]; ok { resultText += fmt.Sprintf("%v ", text) } } } resultBlock.Text = strings.TrimSpace(resultText) toolResults = append(toolResults, resultBlock) } } r.messages = append(r.messages, history.HistoryMessage{ Role: message.GetRole(), Content: messageContent, }) if len(toolResults) > 0 { r.messages = append(r.messages, history.HistoryMessage{ Role: "user", Content: toolResults, }) return r.Run(ctx, "") } return message.GetContent(), nil } ``` Der Code selbst wurde aus Teilen der [Datei](https://github.com/snowmerak/mcphost/blob/main/cmd/mcp.go) zusammengesetzt. Der Inhalt lässt sich grob wie folgt zusammenfassen: 1. Die Werkzeugliste wird zusammen mit dem Prompt gesendet, um eine Entscheidung über die Ausführung oder die Erzeugung einer Antwort anzufordern. 2. Sobald eine Antwort erzeugt wurde, wird die Rekursion beendet und die Antwort zurückgegeben. 3. Wenn das LLM eine Werkzeugausführung anfordert, ruft der Host den MCP-Server auf. 4. Die Antwort wird dem Verlauf hinzugefügt, und es geht zurück zu Schritt 1. ## Zum Schluss > Schon zu Ende? Tatsächlich gibt es nicht allzu viel zu sagen. Dieser Text wurde im Wesentlichen geschrieben, um ein Verständnis dafür zu vermitteln, wie ein MCP-Server funktioniert. Ich hoffe, dass dieser Text Ihnen ein wenig dabei geholfen hat, die Funktionsweise eines MCP-Hosts zu verstehen.