GoSuda

Stručné porozumění MCP host

By snowmerak
views ...

Co je MCP

MCP je protokol vyvinutý společností Anthropic pro claude. MCP je zkratka pro Model Context Protocol a je to protokol, který umožňuje LLM aktivně požadovat akce nebo zdroje externě. Protože MCP je skutečně jen protokol pro poskytování požadavků a odpovědí, proces a provedení musí zajistit vývojář.

O interním fungování

Než se pustíme do vysvětlení interního fungování, podívejme se stručně na Gemini Function Calling. Gemini Function Calling, stejně jako MCP, také umožňuje LLM proaktivně volat externí akce. Pak si možná kladete otázku, proč bylo Function Calling konkrétně zmíněno. Důvodem, proč bylo konkrétně zmíněno, je to, že Function Calling vyšlo dříve než MCP, a jelikož podobně používá schéma OpenAPI, je kompatibilní a předpokládalo se, že jejich vzájemné fungování bude podobné. Protože je vysvětlení Gemini Function Calling poměrně podrobnější, bylo zmíněno, neboť se očekává, že bude nápomocné.

FunctionCalling

Celkový postup je následující.

  1. Definujte funkci.
  2. Odešlete definici funkce do Gemini spolu s promptem.
    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. Pokud Gemini potřebuje, požádá o volání funkce.
    1. Pokud Gemini potřebuje, volající obdrží název a parametry pro volání funkce.
    2. Volající se může rozhodnout, zda provede vykonání, či nikoli.
      1. Zda zavolat a vrátit platnou hodnotu.
      2. Zda vrátit data, jako by byla volána, aniž by se skutečně volala.
      3. Nebo to prostě ignorovat.
  4. V průběhu výše uvedeného procesu Gemini provádí a požaduje akce, jako je volání více funkcí najednou nebo opětovné volání po zobrazení výsledku volání funkce.
  5. Nakonec, když je vytvořena uspořádaná odpověď, proces se ukončí.

Tento postup je obecně v souladu s MCP. Podobně je to vysvětleno i v tutoriálu k MCP. To platí i pro ollama tools.

A naštěstí tyto tři nástroje, ollama tools, MCP a Gemini Function Calling, sdílejí strukturu schématu natolik, že implementace pouze MCP umožňuje jeho použití na všech třech místech.

A ano, existuje nevýhoda, kterou všechny sdílejí. Nakonec, protože model je to, co provádí vykonání, pokud model, který používáte, není v dobré kondici, může dojít k nesprávnému fungování, jako je nevolání funkce, její podivné volání nebo provedení DOS útoku na MCP server.

MCP host v Go

mcphost od mark3lab

V Go existuje mcphost, který je ve vývoji organizací zvanou mark3lab.

Použití je velmi jednoduché.

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

Po instalaci vytvořte soubor $HOME/.mcp.json a napište následující.

 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}

A spusťte s modelem ollama následovně. Samozřejmě, předtím, pokud je to nutné, stáhněte model pomocí ollama pull mistral-small.

Ačkoli se obecně doporučuje claude nebo qwen2.5, já momentálně doporučuji mistral-small.

1mcphost -m ollama:mistral-small

Pokud se však spustí tímto způsobem, lze jej použít pouze ve formátu otázek a odpovědí v prostředí CLI. Proto upravíme kód tohoto mcphost, aby fungoval programovatelněji.

Forkování mcphost

Jak již bylo potvrzeno, mcphost obsahuje funkcionalitu pro extrakci metadat a volání funkcí pomocí MCP. Proto jsou zapotřebí části pro volání LLM, manipulaci s MCP serverem a správu historie zpráv.

Část odpovídající tomuto, která byla přinesena, je Runner následujícího balíčku.

 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}

Interní deklarace odpovídající části nebudeme zvlášť prohlížet. Nicméně je to téměř přesně, jak název napovídá.

 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}

Pro mcpClients a tools zde použité, prosím zkontrolujte tento soubor. Jelikož provider použije ten od ollama, prosím zkontrolujte tento soubor.

Hlavním chodem je metoda 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) // Chyba při volání nástroje %s: %v
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 je složeninou části kódu z tohoto souboru.

Obsah je zhruba následující.

  1. Odešlete seznam nástrojů spolu s promptem, abyste požádali o provedení nebo generování odpovědi.
  2. Pokud je odpověď vygenerována, zastavte rekurzi a vraťte ji.
  3. Pokud LLM zanechá požadavek na provedení nástroje, host volá MCP Server.
  4. Přidejte odpověď do historie a vraťte se ke kroku 1.

Závěrem

Už konec?

Vlastně toho není tolik k řečení. Tento článek byl napsán, aby vám pomohl zhruba porozumět, jak funguje MCP Server. Doufám, že vám tento článek alespoň trochu pomohl pochopit fungování MCP hosta.