GoSuda

Să înțelegem puțin gazda MCP

By snowmerak views ...

Ce este MCP

MCP este un protocol dezvoltat de Anthropic pentru Claude. MCP este abrevierea de la Model Context Protocol și este un protocol care permite LLM-ului să solicite activ acțiuni sau resurse din exterior. Deoarece MCP este, literalmente, doar un protocol care transmite cereri și răspunsuri, procesul și execuția trebuie realizate de dezvoltator.

Despre funcționarea internă

Înainte de a explica funcționarea internă, să facem o scurtă paranteză despre Gemini Function Calling. Gemini Function Calling, la fel ca MCP, permite LLM-ului să invoce în mod proactiv acțiuni externe. Probabil vă veți întreba de ce am adus în discuție Function Calling. Motivul este că Function Calling a apărut înaintea MCP și, întrucât utilizează același schema OpenAPI, este compatibil cu acesta, motiv pentru care am presupus că funcționarea lor este similară. Astfel, explicația Gemini Function Calling este relativ mai detaliată, ceea ce considerăm că ar fi util.

FunctionCalling

Fluxul general este următorul:

  1. Se definește funcția.
  2. Definiția funcției este trimisă către Gemini împreună cu promptul.
    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 solicită apelul funcției, dacă este necesar.
    1. Dacă Gemini consideră necesar, apelantul primește numele și parametrii pentru apelul funcției.
    2. Apelantul poate decide dacă execută sau nu apelul.
      1. Să apeleze funcția și să returneze o valoare validă
      2. Să nu apeleze funcția, ci să returneze date ca și cum ar fi apelat-o
      3. Să ignore pur și simplu cererea
  4. Gemini poate solicita, în cadrul acestui proces, apelul mai multor funcții simultan sau, după ce analizează rezultatul unui apel, poate efectua și solicita alte apeluri.
  5. Procesul se încheie atunci când se obține un răspuns organizat.

Acest flux este, în general, în concordanță cu MCP. Acest lucru este descris într-un mod similar și în tutorialul MCP. De asemenea, este similar cu ollama tools.

Și, din fericire, aceste trei instrumente, ollama tools, MCP și Gemini Function Calling, au structuri de schemă aproape identice, astfel încât implementând doar MCP se poate utiliza în toate cele trei locuri.

Și un dezavantaj comun tuturor: deoarece modelul este cel care execută efectiv apelurile, dacă modelul utilizat este defectuos, poate să nu apeleze funcția, să o apeleze incorect sau chiar să trimită un DOS către serverul MCP.

Gazda MCP în Go

mcphost al mark3lab

În Go există mcphost, dezvoltat de organizația mark3lab.

Utilizarea este foarte simplă.

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

După instalare, creați fișierul $HOME/.mcp.json și scrieți următoarele:

 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}

Apoi rulați următoarea comandă cu modelul ollama:
Desigur, dacă este necesar, înainte de aceasta descărcați modelul cu ollama pull mistral-small.

În mod implicit recomandăm claude sau qwen2.5, dar personal recomand, deocamdată, mistral-small.

1mcphost -m ollama:mistral-small

Totuși, dacă rulați astfel, puteți utiliza aplicația doar în mediul CLI, sub formă de întrebări și răspunsuri.
De aceea, vom modifica codul mcphost pentru a-l face mai programabil.

Fork-ul mcphost

După cum am văzut deja, mcphost include funcționalitatea de extragere a metadatelor și de apelare a funcțiilor prin MCP. Prin urmare, sunt necesare partea de apelare a LLM-ului, partea de gestionare a serverului MCP și partea de administrare a istoricului mesajelor.

Partea corespunzătoare a fost extrasă în Runner-ul din următorul pachet.

 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}

Nu vom analiza declarațiile interne ale acestei părți. Totuși, sunt aproape identice ca nume.

 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}

Pentru mcpClients și tools care vor fi utilizate aici, vă rugăm să consultați fișierul respectiv.
Pentru provider, vom utiliza cel al ollama, așa că vă rugăm să consultați fișierul respectiv.

Partea principală este 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}

Codul propriu-zis a fost compilat din părți ale fișierului respectiv.

Conținutul, în linii mari, este următorul:

  1. Se trimite lista de unelte împreună cu promptul pentru a solicita fie execuția, fie generarea unui răspuns.
  2. Dacă a fost generat un răspuns, recursivitatea se oprește și acesta este returnat.
  3. Dacă LLM-ul lasă o cerere de execuție a unei unelte, gazda apelează serverul MCP.
  4. Răspunsul este adăugat în istoric, apoi se revine la pasul 1.

În final

Deja s-a terminat?

De fapt, nu am prea multe de spus. Acest articol a fost scris pentru a ajuta la înțelegerea modului în care funcționează un server MCP în linii mari. Sper că acest articol v-a fost de folos, chiar și puțin, pentru a înțelege funcționarea unei gazde MCP.