GoSuda

MCP-Host etwas genauer verstehen

By snowmerak views ...

Was ist MCP

MCP 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 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

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 ä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, das von der Organisation mark3lab entwickelt wird.

Die Verwendung ist sehr einfach.

1go install github.com/mark3labs/mcphost@latest

Nach der Installation erstellt man die Datei $HOME/.mcp.json und schreibt Folgendes hinein:

 1{
 2  "mcpServers": {
 3    "sqlite": {
 4      "command": "uvx",
 5      "args": [
 6        "mcp-server-sqlite",
 7        "--db-path",
 8        "/tmp/foo.db"
 9      ]
10    },
11    "filesystem": {
12      "command": "npx",
13      "args": [
14        "-y",
15        "@modelcontextprotocol/server-filesystem",
16        "/tmp"
17      ]
18    }
19  }
20}

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.

1mcphost -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.

 1package runner
 2
 3import (
 4	"context"
 5	"encoding/json"
 6	"fmt"
 7	"log"
 8	"strings"
 9	"time"
10
11	mcpclient "github.com/mark3labs/mcp-go/client"
12	"github.com/mark3labs/mcp-go/mcp"
13
14	"github.com/mark3labs/mcphost/pkg/history"
15	"github.com/mark3labs/mcphost/pkg/llm"
16)
17
18type Runner struct {
19	provider   llm.Provider
20	mcpClients map[string]*mcpclient.StdioMCPClient
21	tools      []llm.Tool
22
23	messages []history.HistoryMessage
24}

Auf die interne Deklaration dieses Teils gehe ich nicht näher ein. Sie entspricht jedoch größtenteils ihrem Namen.

 1func NewRunner(systemPrompt string, provider llm.Provider, mcpClients map[string]*mcpclient.StdioMCPClient, tools []llm.Tool) *Runner {
 2	return &Runner{
 3		provider:   provider,
 4		mcpClients: mcpClients,
 5		tools:      tools,
 6		messages: []history.HistoryMessage{
 7			{
 8				Role: "system",
 9				Content: []history.ContentBlock{{
10					Type: "text",
11					Text: systemPrompt,
12				}},
13			},
14		},
15	}
16}

Zu den hier verwendeten mcpClients und tools siehe bitte diese Datei.
Für provider verwenden wir den von ollama, siehe bitte diese Datei.

Das Hauptgericht ist die Methode Run.

  1func (r *Runner) Run(ctx context.Context, prompt string) (string, error) {
  2	if len(prompt) != 0 {
  3		r.messages = append(r.messages, history.HistoryMessage{
  4			Role: "user",
  5			Content: []history.ContentBlock{{
  6				Type: "text",
  7				Text: prompt,
  8			}},
  9		})
 10	}
 11
 12	llmMessages := make([]llm.Message, len(r.messages))
 13	for i := range r.messages {
 14		llmMessages[i] = &r.messages[i]
 15	}
 16
 17	const initialBackoff = 1 * time.Second
 18	const maxRetries int = 5
 19	const maxBackoff = 30 * time.Second
 20
 21	var message llm.Message
 22	var err error
 23	backoff := initialBackoff
 24	retries := 0
 25	for {
 26		message, err = r.provider.CreateMessage(
 27			context.Background(),
 28			prompt,
 29			llmMessages,
 30			r.tools,
 31		)
 32		if err != nil {
 33			if strings.Contains(err.Error(), "overloaded_error") {
 34				if retries >= maxRetries {
 35					return "", fmt.Errorf(
 36						"claude is currently overloaded. please wait a few minutes and try again",
 37					)
 38				}
 39
 40				time.Sleep(backoff)
 41				backoff *= 2
 42				if backoff > maxBackoff {
 43					backoff = maxBackoff
 44				}
 45				retries++
 46				continue
 47			}
 48
 49			return "", err
 50		}
 51
 52		break
 53	}
 54
 55	var messageContent []history.ContentBlock
 56
 57	var toolResults []history.ContentBlock
 58	messageContent = []history.ContentBlock{}
 59
 60	if message.GetContent() != "" {
 61		messageContent = append(messageContent, history.ContentBlock{
 62			Type: "text",
 63			Text: message.GetContent(),
 64		})
 65	}
 66
 67	for _, toolCall := range message.GetToolCalls() {
 68		input, _ := json.Marshal(toolCall.GetArguments())
 69		messageContent = append(messageContent, history.ContentBlock{
 70			Type:  "tool_use",
 71			ID:    toolCall.GetID(),
 72			Name:  toolCall.GetName(),
 73			Input: input,
 74		})
 75
 76		parts := strings.Split(toolCall.GetName(), "__")
 77
 78		serverName, toolName := parts[0], parts[1]
 79		mcpClient, ok := r.mcpClients[serverName]
 80		if !ok {
 81			continue
 82		}
 83
 84		var toolArgs map[string]interface{}
 85		if err := json.Unmarshal(input, &toolArgs); err != nil {
 86			continue
 87		}
 88
 89		var toolResultPtr *mcp.CallToolResult
 90		req := mcp.CallToolRequest{}
 91		req.Params.Name = toolName
 92		req.Params.Arguments = toolArgs
 93		toolResultPtr, err = mcpClient.CallTool(
 94			context.Background(),
 95			req,
 96		)
 97
 98		if err != nil {
 99			errMsg := fmt.Sprintf(
100				"Error calling tool %s: %v",
101				toolName,
102				err,
103			)
104			log.Printf("Error calling tool %s: %v", toolName, err)
105
106			toolResults = append(toolResults, history.ContentBlock{
107				Type:      "tool_result",
108				ToolUseID: toolCall.GetID(),
109				Content: []history.ContentBlock{{
110					Type: "text",
111					Text: errMsg,
112				}},
113			})
114
115			continue
116		}
117
118		toolResult := *toolResultPtr
119
120		if toolResult.Content != nil {
121			resultBlock := history.ContentBlock{
122				Type:      "tool_result",
123				ToolUseID: toolCall.GetID(),
124				Content:   toolResult.Content,
125			}
126
127			var resultText string
128			for _, item := range toolResult.Content {
129				if contentMap, ok := item.(map[string]interface{}); ok {
130					if text, ok := contentMap["text"]; ok {
131						resultText += fmt.Sprintf("%v ", text)
132					}
133				}
134			}
135
136			resultBlock.Text = strings.TrimSpace(resultText)
137
138			toolResults = append(toolResults, resultBlock)
139		}
140	}
141
142	r.messages = append(r.messages, history.HistoryMessage{
143		Role:    message.GetRole(),
144		Content: messageContent,
145	})
146
147	if len(toolResults) > 0 {
148		r.messages = append(r.messages, history.HistoryMessage{
149			Role:    "user",
150			Content: toolResults,
151		})
152
153		return r.Run(ctx, "")
154	}
155
156	return message.GetContent(), nil
157}

Der Code selbst wurde aus Teilen der Datei 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.