GoSuda

Pochopenie MCP host

By snowmerak
views ...

Čo je MCP

MCP je protokol vyvinutý spoločnosťou Anthropic pre claude. MCP je skratka pre Model Context Protocol a je to protokol, ktorý umožňuje LLM aktívne požadovať externé akcie alebo zdroje. Keďže MCP je doslova len protokol na vyžiadanie a odpoveď, proces a vykonanie musí zabezpečiť vývojár.

O internom fungovaní

Predtým, než vysvetlím interné fungovanie, objasním Gemini Function Calling. Gemini Function Calling, podobne ako MCP, umožňuje LLM iniciatívne volať externé funkcie. Možno sa pýtate, prečo som spomenul práve Function Calling. Dôvodom je, že Function Calling sa objavil skôr ako MCP a je kompatibilný v tom zmysle, že obe používajú schému OpenAPI, čo naznačuje podobné vzájomné fungovanie. Preto som ho uviedol, keďže opis Gemini Function Calling je podrobnejší a mohol by byť užitočný.

FunctionCalling

Celkový priebeh je nasledovný:

  1. Definuje sa funkcia.
  2. Definícia funkcie sa odošle do Gemini spolu s promptom.
    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, ak je to potrebné, požiada o volanie funkcie.
    1. Ak Gemini potrebuje, volajúci obdrží názov a parametre pre volanie funkcie.
    2. Volajúci môže rozhodnúť, či vykoná volanie alebo nie.
      1. Či zavolať a vrátiť platnú hodnotu.
      2. Či vrátiť dáta, akoby boli volané, bez skutočného volania.
      3. Či jednoducho ignorovať.
  4. Gemini počas tohto procesu vykonáva a požaduje akcie, ako je volanie viacerých funkcií naraz, alebo volanie po vyhodnotení výsledkov predchádzajúceho volania.
  5. Nakoniec, po získaní usporiadanej odpovede, sa proces ukončí.

Tento postup je vo všeobecnosti v súlade s MCP. Podobne je to vysvetlené aj v tutoráli MCP. Platí to aj pre nástroje ollama.

A našťastie, tieto tri nástroje – ollama tools, MCP a Gemini Function Calling – zdieľajú štruktúru schémy do takej miery, že implementáciou jedného MCP je možné ho použiť vo všetkých troch.

A áno, existuje jedna spoločná nevýhoda. Keďže model nakoniec vykonáva operácie, ak je model, ktorý používate, v zlom stave, môže zlyhať pri volaní funkcií, volať ich neobvyklým spôsobom alebo vykonávať nesprávne operácie, ako je napríklad DOS útok na MCP server.

MCP host v Go

mark3lab's mcphost

V Go existuje mcphost, ktorý vyvíja organizácia mark3lab.

Použitie je veľmi jednoduché.

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

Po inštalácii vytvorte súbor $HOME/.mcp.json a napíšte do neho nasledovné:

 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}

Následne ho spustite s modelom ollama. Samozrejme, predtým si môžete stiahnuť model pomocou ollama pull mistral-small, ak je to potrebné.

Hoci sa štandardne odporúča claude alebo qwen2.5, ja v súčasnosti odporúčam mistral-small.

1mcphost -m ollama:mistral-small

Avšak, ak ho spustíte týmto spôsobom, môžete ho použiť iba v režime otázok a odpovedí v CLI prostredí. Preto upravíme kód mcphost, aby fungoval programovateľnejšie.

Fork mcphost

Ako už bolo preukázané, mcphost obsahuje funkcie na extrakciu metadát a volanie funkcií pomocou MCP. Preto sú potrebné časti pre volanie LLM, správu MCP servera a správu histórie správ.

Nasledujúci balík Runner obsahuje tieto časti:

 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}

Vnútorné deklarácie tejto časti nebudem skúmať. V podstate sú pomenované presne tak, ako naznačuje ich funkcia.

 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}

Pre mcpClients a tools nájdete informácie v tomto súbore. Keďže provider bude používať ollama, nájdete informácie v tomto súbore.

Hlavným chodom je metóda 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}

Samotný kód bol zostavený z častí tohto súboru.

Obsah je zhruba nasledovný:

  1. Odošle sa prompt spolu so zoznamom nástrojov, aby sa požiadalo o vykonanie alebo generovanie odpovede.
  2. Ak sa odpoveď vygeneruje, rekurzia sa zastaví a vráti sa hodnota.
  3. Ak LLM zanechá požiadavku na vykonanie nástroja, hostiteľ zavolá MCP Server.
  4. Odpoveď sa pridá do histórie a vráti sa k bodu 1.

Záverom

Už koniec?

V skutočnosti toho nie je veľa na povedanie. Tento článok bol napísaný s cieľom pomôcť vám pochopiť, ako zhruba funguje MCP Server. Dúfam, že tento článok vám aspoň trochu pomohol pochopiť fungovanie MCP host.