MCP-Host: Ein vorläufiges Verständnis
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.
Der Gesamtfluss ist wie folgt:
- Eine Funktion wird definiert.
- Die Funktionsdefinition wird zusammen mit dem Prompt an Gemini gesendet.
- „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.“
- Gemini fordert einen Funktionsaufruf an, falls erforderlich.
- Falls Gemini einen Funktionsaufruf benötigt, erhält der Aufrufer den Namen und die Parameter dafür.
- Der Aufrufer kann entscheiden, ob er die Ausführung vornimmt oder nicht.
- Ob ein Aufruf getätigt und ein gültiger Wert zurückgegeben werden soll.
- Ob Daten zurückgegeben werden sollen, als ob ein Aufruf getätigt wurde, ohne tatsächlich einen zu tätigen.
- Ob der Aufruf einfach ignoriert werden soll.
- 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.
- 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:
- Eine Liste von Tools wird zusammen mit dem Prompt gesendet, um die Ausführung oder die Generierung einer Antwort anzufordern.
- Wenn eine Antwort generiert wird, wird die Rekursion beendet und die Antwort zurückgegeben.
- Wenn das LLM eine Tool-Ausführungsanforderung hinterlässt, ruft der Host den MCP Server auf.
- 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.