MCP LAN-test

Hvad tester vi?

Vi tester, om én MCP-server kan køre i Docker på MIKC's PC, mens Lektor Hansen og András forbinder fra deres egne PC'er over et lokalt Wi-Fi og bruger den samme shared.txt.

Målet er at vise:

• at MCP-serveren ikke behøver køre på samme PC som klienten

• at flere klienter kan bruge den samme MCP-server

• at klienterne ikke får direkte adgang til MIKC's filsystem

• at GitHub Copilot kan bruge MCP-serverens tools

• at Docker giver MCP-serveren kontrolleret adgang til shared.txt

flowchart LR
    H["Mikkel Lektor Hansen<br>Copilot / MCP-klient"]
    A["András<br>Copilot / MCP-klient"]
    R["Wi-Fi: AIgutterne"]

    subgraph MIKC["MIKC's PC"]
        P["Port 3001"]
        D["Docker"]
        M["MCP-server<br>port 3000"]
        F["shared/shared.txt"]
        P --> D
        D --> M
        M --> F
    end

    H --> R
    A --> R
    R --> P

Related MCP server: High-Performance File System MCP Server

Roller

MIKC

MIKC har serveren og skal:

1. forbinde sin PC til Wi-Fi-netværket AIgutterne

2. starte Docker Desktop

3. finde sin IP-adresse med:

ipconfig

4. sætte IP-adressen i .env, fx:

MCP_TOKEN=min-hemmelige-lan-token
ALLOWED_HOSTS=localhost,127.0.0.1,192.168.8.100

5. starte MCP-serveren:

docker compose down
docker compose up --build -d

6. kontrollere at den kører:

docker compose ps

Der skal stå noget i retning af:

0.0.0.0:3001->3000/tcp

7. teste serveren:

curl.exe http://127.0.0.1:3001/health

Forventet:

{"status":"ok"}

Vigtigt om /mcp

Hvis man åbner:

http://127.0.0.1:3001/mcp

direkte i en browser, får man:

{"error":"Unauthorized"}

Det er forventet.

Browseren sender ikke vores MCP-token i Authorization-headeren. Det viser faktisk, at MCP-serveren svarer, og at adgangskontrollen virker.

Brug derfor /health til den simple browsertest og MCP-klienten eller Copilot til selve MCP-testen.

Lektor Hansen og András

De er klienter og skal ikke køre:

npm start

Det ville forsøge at starte deres egen MCP-server.

De skal kun have:

• Node.js installeret

• projektet klonet

• kørt npm install

• deres IDE / Copilot klar

Først: test med Node-klienten

Antag at MIKC får IP-adressen:

192.168.8.100

På Lektor Hansens og András' PC:

Test-NetConnection 192.168.8.100 -Port 3001

Vi vil se:

TcpTestSucceeded : True

Derefter: kKlienttesten -> Den bruges før Copilot, så vi først beviser, at MCP-forbindelsen over LAN virker.

$env:MCP_URL="http://192.168.8.100:3001/mcp"
$env:MCP_TOKEN="min-hemmelige-lan-token"

npm run client

Klienten læser shared.txt, skriver en linje og læser filen igen.

MIKC kan samtidig åbne:

shared/shared.txt

og se ændringerne.

MCP-konfiguration til Copilot

Når Node-klienten virker, tester vi GitHub Copilot eller anden agent.

MIKC – lokal Copilot

På MIKC's PC:

{
  "servers": {
    "lan-file-server": {
      "url": "http://127.0.0.1:3001/mcp",
      "requestInit": {
        "headers": {
          "Authorization": "Bearer min-hemmelige-lan-token"
        }
      }
    }
  }
}

Lektor Hansen og András – Copilot over LAN

Begge bruger MIKC's IP-adresse:

{
  "servers": {
    "lan-file-server": {
      "url": "http://192.168.8.100:3001/mcp",
      "requestInit": {
        "headers": {
          "Authorization": "Bearer min-hemmelige-lan-token"
        }
      }
    }
  }
}

Erstat 192.168.8.100 med MIKC's faktiske IP-adresse på AIgutterne.

I JetBrains åbnes Copilot Chat i Agent mode, derefter Tools / Configure MCP server → Add MCP Tools, og konfigurationen indsættes i mcp.json.

Copilot bør derefter kunne se:

read_text_file
write_text_file
append_text_file

Test med Copilot

På lektor Hansens PC:

Brug MCP-serveren til at læse den delte tekstfil.

Derefter:

Brug MCP-serveren til at tilføje:
"Hej fra lektor Hansens Copilot"

På András' PC:

Læs den delte tekstfil gennem MCP og tilføj:
"Hej fra András' Copilot"

MIKC åbner derefter shared/shared.txt.

Hvis begge tekster står i filen, har vi vist:

Mikkel Lektor Hansen ─┐
                      ├── MCP-server i Docker ── shared.txt
András ────────────────┘

Hvad gør Docker?

Docker kører MCP-serveren isoleret.

Serveren ser filen som:

/data/shared.txt

men docker-compose.yml mapper:

volumes:
  - ./shared:/data

så den virkelige fil ligger på MIKC's PC:

shared/shared.txt

Klienterne får derfor ikke direkte adgang til MIKC's filsystem. De kan kun gøre det, MCP-serverens tools tillader.

Hvad kan vi konkludere?

Hvis testen virker, har vi vist:

• én MCP-server kan deles af flere klienter

• MCP kan bruges over et lokalt netværk

• Mikkel Lektor Hansen og András behøver ikke Docker

• klienterne behøver ikke direkte adgang til filen

• Docker kan give MCP-serveren kontrolleret adgang til lokale data

• Copilot kan bruge samme remote MCP-server som en almindelig MCP-klient