GoSuda

MCP-Host: Ein vorläufiges Verständnis

By snowmerak
views ...

Was ist MCP?

MCP ist ein Protokoll, das von Anthropic für Claude entwickelt wurde. MCP ist die Abkürzung für Model Context Protocol und ermöglicht es einem LLM, aktiv externe Aktionen oder Ressourcen anzufordern. Da MCP lediglich ein Protokoll für Anfragen und Antworten ist, müssen der Prozess und die Ausführung vom Entwickler vorgenommen werden.

Über die interne Funktionsweise

Bevor die interne Funktionsweise erläutert wird, soll Gemini Function Calling kurz behandelt werden. Gemini Function Calling ermöglicht es dem LLM, proaktiv externe Aktionen aufzurufen, genau wie MCP. Es mag die Frage aufkommen, warum Function Calling hier überhaupt erwähnt wird. Der Grund dafür ist, dass Function Calling vor MCP entstanden ist und beide die OpenAPI-Schema nutzen, was Kompatibilität ermöglicht und eine ähnliche Funktionsweise vermuten lässt. Da die Erläuterungen zu Gemini Function Calling detaillierter sind, wurden sie als hilfreich erachtet und hierher übernommen.

FunctionCalling

Der Gesamtfluss ist wie folgt:

  1. Eine 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 einen Funktionsaufruf an, falls erforderlich.
    1. Falls Gemini einen Funktionsaufruf benötigt, erhält der Aufrufer den Namen und die Parameter dafür.
    2. Der Aufrufer kann entscheiden, ob er die Ausführung vornimmt oder nicht.
      1. Ob ein Aufruf getätigt und ein gültiger Wert zurückgegeben werden soll.
      2. Ob Daten zurückgegeben werden sollen, als ob ein Aufruf getätigt wurde, ohne tatsächlich einen zu tätigen.
      3. Ob der Aufruf einfach ignoriert werden soll.
  4. Gemini führt in diesem Prozess mehrere Funktionen gleichzeitig aus oder fordert sie an, oder führt nach einem Funktionsaufruf weitere Aufrufe basierend auf den Ergebnissen aus.
  5. Wenn schließlich eine geordnete Antwort vorliegt, wird der Vorgang beendet.

Dieser Ablauf stimmt im Allgemeinen mit MCP überein. Dies wird auch im MCP-Tutorial ähnlich beschrieben. Dies gilt auch für Ollama Tools.

Und glücklicherweise teilen diese drei Tools – Ollama Tools, MCP und Gemini Function Calling – eine gemeinsame Schema-Struktur, sodass die Implementierung von nur einem MCP die Nutzung an allen drei Orten ermöglicht.

Und es gibt einen Nachteil, den alle teilen: Da letztendlich das Modell die Ausführung vornimmt, kann es bei schlechtem Zustand des von Ihnen verwendeten Modells zu Fehlfunktionen kommen, wie dem Nichtaufruf von Funktionen, fehlerhaften Aufrufen oder DOS-Angriffen auf den MCP-Server.

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 erstellen Sie die Datei $HOME/.mcp.json und fügen Sie den folgenden Inhalt ein:

 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}

Führen Sie es dann mit dem Ollama-Modell wie folgt aus: Falls erforderlich, laden Sie das Modell zuvor mit ollama pull mistral-small herunter.

Obwohl standardmäßig Claude oder Qwen2.5 empfohlen werden, empfehle ich derzeit Mistral-small.

1mcphost -m ollama:mistral-small

Wenn Sie es jedoch so ausführen, können Sie es nur im CLI-Modus für Fragen und Antworten verwenden. Daher werden wir den Code dieses mcphost ändern, um ihn programmierbarer zu gestalten.

mcphost-Fork

Wie bereits festgestellt, enthält mcphost Funktionen zur Metadatenextraktion und Funktionsaufrufe unter Verwendung von MCP. Daher sind Teile für den Aufruf des LLM, die Handhabung des MCP-Servers und die Verwaltung des Nachrichtenverlaufs erforderlich.

Der Runner des folgenden Pakets enthält die entsprechenden Teile:

 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}

Die interne Deklaration dieses Teils wird nicht separat betrachtet. Der Name ist jedoch fast selbsterklärend.

 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}

Für mcpClients und tools, die hier verwendet werden, siehe bitte diese Datei. Da der provider der von Ollama sein wird, siehe bitte diese Datei.

Das Hauptgericht ist die Run-Methode.

  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 ist grob wie folgt:

  1. Eine Liste von Tools wird zusammen mit dem Prompt gesendet, um die Ausführung oder die Generierung einer Antwort anzufordern.
  2. Wenn eine Antwort generiert wird, wird die Rekursion beendet und die Antwort zurückgegeben.
  3. Wenn das LLM eine Tool-Ausführungsanforderung hinterlässt, ruft der Host den MCP Server auf.
  4. Die Antwort wird zum Verlauf hinzugefügt, und der Prozess kehrt zu Schritt 1 zurück.

Zum Schluss

Schon am Ende?

Es gibt eigentlich nicht viel zu sagen. Dieser Artikel wurde geschrieben, um ein grundlegendes Verständnis der Funktionsweise des MCP Servers zu vermitteln. Ich hoffe, dieser Artikel hat Ihnen ein kleines bisschen geholfen, die Funktionsweise des MCP-Hosts zu verstehen.