---
id: a1fad13de24c90924cfa9e25e9f986cb
author: snowmerak
title: Litt om å forstå MCP host
description: Dette er en artikkel som skal bidra til å gi en forståelse av Anthropics MCP-protokoll og MCP-verten (mcphost) implementert i Go.
language: "no"
date: 2025-04-08T00:59:42.416582136Z
path: /blog/posts/a-little-understanding-of-mcp-host-zb952aae0
category: ai
---

## Hva er MCP

[MCP](https://modelcontextprotocol.io/introduction) er en protokoll utviklet av Anthropic for Claude. MCP er en forkortelse for Model Context Protocol, og er en protokoll som gjør det mulig for en LLM å aktivt be om handlinger eller ressurser fra eksterne systemer. Siden MCP i bokstavelig forstand bare er en protokoll for å sende forespørsler og motta svar, må utvikleren selv håndtere prosessen og utførelsen.

### Om den interne virkemåten

Før jeg forklarer den interne virkemåten, vil jeg kort gjennomgå [Gemini Function Calling](https://ai.google.dev/gemini-api/docs/function-calling). Gemini Function Calling gjør det også mulig for en LLM å aktivt kalle eksterne funksjoner, på samme måte som MCP. Du vil kanskje lure på hvorfor Function Calling tas med her. Grunnen er at Function Calling kom før MCP, og at begge bruker OpenAPI-skjemaer, noe som gjør dem kompatible; derfor antok jeg at deres interne virkemåte ligner hverandre. Ettersom forklaringen av Gemini Function Calling er relativt detaljert, vil den sannsynligvis være nyttig, og derfor er den tatt med.

![FunctionCalling](/assets/images/mcp_with_csharp/function-calling-overview.png)

Den overordnede flyten er som følger.

1. Definer funksjonen.
2. Send funksjonsdefinisjonen til Gemini sammen med prompten.
   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 ber om et funksjonskall hvis det er nødvendig.
   1. Dersom Gemini trenger et funksjonskall, mottar kalleren navnet og parameterne for kallet.
   2. Kalleren kan selv velge om den vil utføre kallet eller ikke.
      1. Utføre kallet og returnere en gyldig verdi
      2. Returnere data som om kallet var utført, uten å faktisk utføre det
      3. Ignorere det
4. I løpet av denne prosessen kan Gemini be om flere funksjonskall samtidig, eller utføre og be om flere kall etter å ha sett resultatet av forrige kall.
5. Når et ryddig svar foreligger, avsluttes prosessen.

Denne flyten samsvarer i hovedsak med MCP. Det er også forklart på lignende måte i [MCPs veiledning](https://modelcontextprotocol.io/tutorials/building-mcp-with-llms). Ollama tools fungerer også på omtrent samme måte.

Og heldigvis deler disse tre verktøyene, Ollama tools, MCP og Gemini Function Calling, nesten samme skjemastruktur, slik at man kan bruke alle tre ved å implementere bare MCP.

Og så er det en ulempe som alle deler. Siden det er modellen som faktisk utfører kallene, kan en modell i dårlig forfatning unnlate å kalle funksjoner, kalle dem feil, eller til og med overbelaste MCP-serveren med DoS-lignende forespørsler.

## MCP-vert i Go

### mark3lab sin mcphost

I Go finnes [mcphost](https://github.com/mark3labs/mcphost), som utvikles av organisasjonen mark3lab.

Bruken er svært enkel.

```sh
go install github.com/mark3labs/mcphost@latest
```

Etter installasjonen oppretter du filen `$HOME/.mcp.json` og skriver følgende i den.

```json
{
  "mcpServers": {
    "sqlite": {
      "command": "uvx",
      "args": [
        "mcp-server-sqlite",
        "--db-path",
        "/tmp/foo.db"
      ]
    },
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/tmp"
      ]
    }
  }
}
```

Deretter kjører du det med en Ollama-modell som følger.  
Før det, om nødvendig, hent modellen med `ollama pull mistral-small`.

> Generelt anbefales Claude eller qwen2.5, men foreløpig anbefaler jeg mistral-small.

```sh
mcphost -m ollama:mistral-small
```

Når du kjører det på denne måten, kan du bare bruke det som spørsmål og svar i et CLI-miljø.  
Derfor skal vi endre koden i `mcphost` slik at den kan fungere mer programmerbart.

### Fork av mcphost

Som vi allerede har sett, inneholder `mcphost` funksjonalitet for å hente metadata og kalle funksjoner via MCP. Derfor trenger vi en del som kaller LLM, en del som håndterer MCP-serveren, og en del som administrerer meldingshistorikken.

Delen som dekker dette er `Runner` i følgende pakke.

```go
package runner

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"strings"
	"time"

	mcpclient "github.com/mark3labs/mcp-go/client"
	"github.com/mark3labs/mcp-go/mcp"

	"github.com/mark3labs/mcphost/pkg/history"
	"github.com/mark3labs/mcphost/pkg/llm"
)

type Runner struct {
	provider   llm.Provider
	mcpClients map[string]*mcpclient.StdioMCPClient
	tools      []llm.Tool

	messages []history.HistoryMessage
}
```

Den interne deklarasjonen av denne delen går jeg ikke gjennom separat. Navnene er imidlertid nesten selvforklarende.

```go
func NewRunner(systemPrompt string, provider llm.Provider, mcpClients map[string]*mcpclient.StdioMCPClient, tools []llm.Tool) *Runner {
	return &Runner{
		provider:   provider,
		mcpClients: mcpClients,
		tools:      tools,
		messages: []history.HistoryMessage{
			{
				Role: "system",
				Content: []history.ContentBlock{{
					Type: "text",
					Text: systemPrompt,
				}},
			},
		},
	}
}
```

For `mcpClients` og `tools` som brukes her, se [denne filen](https://github.com/snowmerak/mcphost/blob/main/internal/runner/from.go).  
For `provider` bruker vi Ollamas variant, så se [denne filen](https://github.com/snowmerak/mcphost/blob/main/pkg/llm/ollama/provider.go).

Hovedretten er metoden `Run`.

```go
func (r *Runner) Run(ctx context.Context, prompt string) (string, error) {
	if len(prompt) != 0 {
		r.messages = append(r.messages, history.HistoryMessage{
			Role: "user",
			Content: []history.ContentBlock{{
				Type: "text",
				Text: prompt,
			}},
		})
	}

	llmMessages := make([]llm.Message, len(r.messages))
	for i := range r.messages {
		llmMessages[i] = &r.messages[i]
	}

	const initialBackoff = 1 * time.Second
	const maxRetries int = 5
	const maxBackoff = 30 * time.Second

	var message llm.Message
	var err error
	backoff := initialBackoff
	retries := 0
	for {
		message, err = r.provider.CreateMessage(
			context.Background(),
			prompt,
			llmMessages,
			r.tools,
		)
		if err != nil {
			if strings.Contains(err.Error(), "overloaded_error") {
				if retries >= maxRetries {
					return "", fmt.Errorf(
						"claude is currently overloaded. please wait a few minutes and try again",
					)
				}

				time.Sleep(backoff)
				backoff *= 2
				if backoff > maxBackoff {
					backoff = maxBackoff
				}
				retries++
				continue
			}

			return "", err
		}

		break
	}

	var messageContent []history.ContentBlock

	var toolResults []history.ContentBlock
	messageContent = []history.ContentBlock{}

	if message.GetContent() != "" {
		messageContent = append(messageContent, history.ContentBlock{
			Type: "text",
			Text: message.GetContent(),
		})
	}

	for _, toolCall := range message.GetToolCalls() {
		input, _ := json.Marshal(toolCall.GetArguments())
		messageContent = append(messageContent, history.ContentBlock{
			Type:  "tool_use",
			ID:    toolCall.GetID(),
			Name:  toolCall.GetName(),
			Input: input,
		})

		parts := strings.Split(toolCall.GetName(), "__")

		serverName, toolName := parts[0], parts[1]
		mcpClient, ok := r.mcpClients[serverName]
		if !ok {
			continue
		}

		var toolArgs map[string]interface{}
		if err := json.Unmarshal(input, &toolArgs); err != nil {
			continue
		}

		var toolResultPtr *mcp.CallToolResult
		req := mcp.CallToolRequest{}
		req.Params.Name = toolName
		req.Params.Arguments = toolArgs
		toolResultPtr, err = mcpClient.CallTool(
			context.Background(),
			req,
		)

		if err != nil {
			errMsg := fmt.Sprintf(
				"Error calling tool %s: %v",
				toolName,
				err,
			)
			log.Printf("Error calling tool %s: %v", toolName, err)

			toolResults = append(toolResults, history.ContentBlock{
				Type:      "tool_result",
				ToolUseID: toolCall.GetID(),
				Content: []history.ContentBlock{{
					Type: "text",
					Text: errMsg,
				}},
			})

			continue
		}

		toolResult := *toolResultPtr

		if toolResult.Content != nil {
			resultBlock := history.ContentBlock{
				Type:      "tool_result",
				ToolUseID: toolCall.GetID(),
				Content:   toolResult.Content,
			}

			var resultText string
			for _, item := range toolResult.Content {
				if contentMap, ok := item.(map[string]interface{}); ok {
					if text, ok := contentMap["text"]; ok {
						resultText += fmt.Sprintf("%v ", text)
					}
				}
			}

			resultBlock.Text = strings.TrimSpace(resultText)

			toolResults = append(toolResults, resultBlock)
		}
	}

	r.messages = append(r.messages, history.HistoryMessage{
		Role:    message.GetRole(),
		Content: messageContent,
	})

	if len(toolResults) > 0 {
		r.messages = append(r.messages, history.HistoryMessage{
			Role:    "user",
			Content: toolResults,
		})

		return r.Run(ctx, "")
	}

	return message.GetContent(), nil
}
```

Koden er satt sammen av deler fra [denne filen](https://github.com/snowmerak/mcphost/blob/main/cmd/mcp.go).

Innholdet kan oppsummeres slik:

1. Send prompten sammen med verktøylisten og be om enten en vurdering av kjøring eller et generert svar.
2. Når et svar er generert, stopper rekursjonen og svaret returneres.
3. Dersom LLM legger igjen en forespørsel om verktøykjøring, kaller verten MCP-serveren.
4. Legg resultatet til i historikken og gå tilbake til punkt 1.

## Til slutt

> Allerede slutt?

Egentlig er det ikke så mye mer å si. Teksten er skrevet for å gi en forståelse av hvordan en MCP-server fungerer. Jeg håper den har bidratt, om så bare litt, til å forstå hvordan en MCP-vert fungerer.