GoSuda

Krótkie zrozumienie hosta MCP

By snowmerak views ...

Czym jest MCP

MCP to protokół opracowany przez Anthropic z myślą o claude. MCP jest skrótem od Model Context Protocol i jest to protokół umożliwiający LLM aktywne żądanie działań lub zasobów od świata zewnętrznego. Ponieważ MCP jest dosłownie protokołem jedynie przekazującym żądania i odpowiedzi, sam proces oraz wykonanie muszą zostać zrealizowane przez programistę.

O działaniu wewnętrznym

Zanim wyjaśnię działanie wewnętrzne, chciałbym krótko omówić Gemini Function Calling. Gemini Function Calling, podobnie jak MCP, pozwala LLM na samodzielne wywoływanie działań zewnętrznych. Można się zastanawiać, dlaczego w ogóle przywołuję Function Calling. Powodem jest to, że Function Calling pojawiło się wcześniej niż MCP oraz że oba rozwiązania korzystają z tego samego schematu OpenAPI, dzięki czemu są ze sobą kompatybilne, a ich działanie można uznać za podobne. Ponieważ dokumentacja Gemini Function Calling jest stosunkowo szczegółowa, uznałem, że może ona być pomocna, dlatego ją uwzględniłem.

FunctionCalling

Ogólny przebieg wygląda następująco.

  1. Definiujemy funkcję.
  2. Wysyłamy definicję funkcji do Gemini wraz z 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. Gemini w razie potrzeby żąda wywołania funkcji.
    1. Jeśli Gemini uzna to za potrzebne, wywołujący otrzymuje nazwę i parametry niezbędne do wywołania funkcji.
    2. Wywołujący może zdecydować, czy wykonać wywołanie, czy nie.
      1. Wywołać funkcję i zwrócić prawidłową wartość
      2. Nie wywoływać funkcji, lecz zwrócić dane tak, jakby została wywołana
      3. Zignorować żądanie
  4. Gemini w powyższym procesie może jednocześnie żądać wywołania wielu funkcji lub, po otrzymaniu wyniku wywołania, żądać kolejnych wywołań i wykonywać dalsze operacje.
  5. Proces kończy się, gdy zostanie wygenerowana uporządkowana odpowiedź.

Ten przebieg jest ogólnie zgodny z MCP. Podobnie opisuje go samouczek MCP. Podobny jest także mechanizm ollama tools.

Co więcej, i to naprawdę szczęśliwie, te trzy narzędzia: ollama tools, MCP oraz Gemini Function Calling mają niemal wspólną strukturę schematu, dzięki czemu implementując jedynie MCP, można go używać we wszystkich trzech miejscach.

Ah, jest też wada wspólna dla wszystkich tych rozwiązań. Ponieważ to model faktycznie wykonuje wywołania, jeśli używany model działa słabo, może nie wywołać funkcji, wywołać ją w nieprawidłowy sposób lub wygenerować nadmierne obciążenie serwera MCP (np. atak DoS), czyli zachowywać się nieprawidłowo.

Host MCP w Go

mcphost autorstwa mark3lab

W języku Go istnieje mcphost, rozwijany przez organizację mark3lab.

Jego użycie jest bardzo proste.

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

Po instalacji utwórz plik $HOME/.mcp.json i zapisz w nim następującą treść.

 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}

Następnie uruchom go z modelem ollama w następujący sposób.
Oczywiście wcześniej, jeśli to konieczne, pobierz model poleceniem ollama pull mistral-small.

Ogólnie polecam claude lub qwen2.5, jednak osobiście obecnie rekomenduję mistral-small.

1mcphost -m ollama:mistral-small

Jednak po takim uruchomieniu można korzystać z niego wyłącznie w formie zapytań i odpowiedzi w środowisku CLI.
Dlatego zmodyfikujemy kod mcphost, aby działał bardziej programowalnie.

Fork mcphost

Jak już wiadomo, mcphost zawiera funkcję wykorzystującą MCP do pozyskiwania metadanych oraz wywoływania funkcji. Dlatego potrzebne są części odpowiedzialne za wywoływanie LLM, obsługę serwera MCP oraz zarządzanie historią wiadomości.

Część odpowiadająca tym funkcjom to Runner z poniższego pakietu.

 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}

Wewnętrzne deklaracje tej części nie będą tu omawiane. Są one jednak niemal identyczne z nazwami, które noszą.

 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}

Informacje o mcpClients oraz tools, które tu są używane, znajdziesz w tym pliku.
Jako provider użyjemy implementacji z ollama, więc zajrzyj do tego pliku.

Najważniejszym elementem jest 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)
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}

Sam kod został złożony z fragmentów tego pliku.

Ogólnie wygląda to następująco.

  1. Wysyłamy prompt wraz z listą narzędzi, prosząc o decyzję o wykonaniu lub wygenerowanie odpowiedzi.
  2. Gdy odpowiedź zostanie wygenerowana, przerywamy rekurencję i zwracamy wynik.
  3. Jeśli LLM zażąda wykonania narzędzia, host wywołuje serwer MCP.
  4. Dodajemy odpowiedź do historii i wracamy do punktu 1.

Na koniec

Już koniec?

Właściwie nie mam wiele więcej do powiedzenia. Artykuł ten powstał, aby pomóc w zrozumieniu tego, jak działa serwer MCP. Mam nadzieję, że choć odrobinę przyczynił się do zrozumienia działania hosta MCP.