GoSuda

MCP host etwas besser verstehen

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 buchstäblich nur ein Protokoll für Anfragen und Antworten ist, müssen der Prozess und die Ausführung vom Entwickler durchgeführt werden.

Über die interne Funktionsweise

Bevor ich die interne Funktionsweise erläutere, möchte ich auf Gemini Function Calling eingehen. Gemini Function Calling ermöglicht es dem LLM, externe Aktionen proaktiv auf dieselbe Weise wie MCP aufzurufen. Es mag sich die Frage stellen, warum Function Calling überhaupt erwähnt wird. Der Grund dafür ist, dass Function Calling vor MCP existierte und mit MCP kompatibel ist, da beide das OpenAPI-Schema verwenden, was auf eine ähnliche Interaktion hindeutet. Daher wurde die detailliertere Beschreibung von Gemini Function Calling als hilfreich erachtet.

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 bei Bedarf einen Funktionsaufruf an.
    1. Wenn Gemini einen Funktionsaufruf benötigt, 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. Ob ein gültiger Wert nach dem Aufruf zurückgegeben werden soll.
      2. Ob Daten zurückgegeben werden sollen, als ob ein Aufruf erfolgt wäre, ohne tatsächlich aufzurufen.
      3. Ob der Aufruf einfach ignoriert werden soll.
  4. Gemini führt und fordert in diesem Prozess mehrere Funktionen gleichzeitig auf oder ruft nach der Überprüfung der Ergebnisse eines Funktionsaufrufs weitere Aufrufe an.
  5. Der Prozess endet, wenn eine geordnete Antwort vorliegt.

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 sich diese drei Tools, ollama tools, MCP und Gemini Function Calling, eine ähnliche Schema-Struktur, sodass die Implementierung von nur einem MCP für alle drei Anwendungen genutzt werden kann.

Ach ja, und es gibt einen gemeinsamen Nachteil: Da letztendlich das Modell die Ausführung übernimmt, kann es, wenn das von Ihnen verwendete Modell in einem schlechten Zustand ist, zu Fehlfunktionen kommen, wie z. B. das Nichtaufrufen von Funktionen, das fehlerhafte Aufrufen oder das Ausführen eines DOS-Angriffs 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 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}

Und führen Sie es dann mit dem ollama-Modell wie folgt aus: Zuvor können Sie natürlich das Modell mit ollama pull mistral-small herunterladen, falls erforderlich.

Grundsätzlich werden claude oder qwen2.5 empfohlen, aber ich empfehle derzeit mistral-small.

1mcphost -m ollama:mistral-small

Wenn Sie es jedoch so ausführen, kann es nur im CLI-Modus für Fragen und Antworten verwendet werden. Daher werden wir den Code von 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 Verwaltung des MCP-Servers und die Verwaltung der Nachrichtenhistorie 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 werde ich nicht separat betrachten. Sie ist jedoch fast wörtlich.

 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}

Die hier verwendeten mcpClients und tools finden Sie in dieser Datei. Für den provider, der von ollama verwendet wird, sehen Sie 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 ist ein Zusammenschnitt von Teilen des Codes aus dieser Datei.

Der Inhalt ist ungefähr 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 gestoppt 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 zur Historie hinzugefügt, und der Prozess kehrt zu Schritt 1 zurück.

Zum Abschluss

Schon vorbei?

Tatsächlich gibt es nicht viel zu sagen. Dieser Artikel wurde verfasst, um Ihnen ein grundlegendes Verständnis der Funktionsweise eines MCP Servers zu vermitteln. Ich hoffe, dieser Artikel hat Ihnen ein wenig geholfen, die Funktionsweise eines MCP-Hosts zu verstehen.