# Agent MCP Server Probe Guide

Zweck: Diese Kurz-Anleitung zeigt Agenten, wie der laufende SindByte-MCP-Server direkt per HTTP geprüft wird, ohne VS Code oder Cline zu verändern.

## Ort und Voraussetzung

- Projektordner: `F:\00_MR\MR_Komponents\Internet-SLL\HTP_JSON_Lib`
- Server-Endpunkt: `http://127.0.0.1:5559/mcp`
- API-Provider: `http://127.0.0.1:8091/v1/models` (48 Modelle)
- Voraussetzung: `SindByte 01.exe` oder der Server läuft bereits.

## Wichtig

- Nichts in VS Code, Cline oder deren Config eintragen, wenn nur der Server geprüft werden soll.
- Für reine Laufzeitdiagnose direkte HTTP-Requests aus PowerShell verwenden.
- `GET /mcp` liefert derzeit eine `NullReferenceException` (bekanntes Problem, PROB-AUTO-001). Das ist harmlos.
- `POST /mcp` mit JSON-RPC ist der funktionierende Pfad für Tool-Aufrufe.

## 1. JSON-RPC Tool-Call prüfen (Empfohlen)

Dieser Probe zeigt den tatsächlichen funktionierenden Aufrufpfad:

```powershell
$body = @{
    jsonrpc = "2.0"
    id      = 1
    method  = "tools/call"
    params  = @{
        name      = "SystemTools::GetBaseDir"
        arguments = @{}
    }
} | ConvertTo-Json -Depth 5

Invoke-RestMethod -Uri 'http://127.0.0.1:5559/mcp' -Method Post `
    -ContentType 'application/json' -Body $body
```

Erwartet:

- HTTP `200`
- JSON-RPC-Response mit `result.content[0].text` = aktuelles Basis-Verzeichnis

## 2. SSE-Handshake prüfen (Optional)

Dieser Probe zeigt, ob der Server auf `GET /mcp` mit einem offenen SSE-Handshake antwortet.
Hinweis: Derzeit wird eine NullReferenceException zurückgegeben — das ist ein bekanntes Problem.

```powershell
$req=[System.Net.HttpWebRequest]::Create('http://127.0.0.1:5559/mcp')
$req.Method='GET'
$req.Accept='text/event-stream'
$req.Timeout=5000
$req.ReadWriteTimeout=5000
try {
    $resp=$req.GetResponse()
    [pscustomobject]@{
        StatusCode  = [int]$resp.StatusCode
        ContentType = $resp.ContentType
        Headers     = $resp.Headers
    }
    $resp.Close()
} catch {
    Write-Host "GET /mcp liefert Exception (erwartet/bekannt): $($_.Exception.Message)" -ForegroundColor Yellow
}
```

## 3. Initialize per POST prüfen

Dieser Request prüft, ob der Server moderne MCP-Initialisierung per JSON korrekt beantwortet.

```powershell
$initBody='{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"CodexProbe","version":"1.0"}}}'

$init=Invoke-WebRequest `
  -Uri 'http://127.0.0.1:5559/mcp' `
  -Method Post `
  -ContentType 'application/json' `
  -Headers @{
    Accept='application/json, text/event-stream'
    'MCP-PROTOCOL-VERSION'='2025-11-25'
  } `
  -Body $initBody `
  -UseBasicParsing `
  -TimeoutSec 20

$init.StatusCode
$init.Headers['Mcp-Session-Id']
$init.Content
```

Erwartet:

- HTTP `200`
- Header `Mcp-Session-Id`
- JSON-RPC-`result` mit:
  - `protocolVersion`
  - `serverInfo`
  - `capabilities`

## 4. Tools-Liste abfragen

Mit der Session aus `initialize` kann direkt `tools/list` geprüft werden.

```powershell
$sid=$init.Headers['Mcp-Session-Id']
$body='{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

$resp=Invoke-WebRequest `
  -Uri 'http://127.0.0.1:5559/mcp' `
  -Method Post `
  -ContentType 'application/json' `
  -Headers @{
    Accept='application/json, text/event-stream'
    'MCP-PROTOCOL-VERSION'='2025-11-25'
    'Mcp-Session-Id'=$sid
  } `
  -Body $body `
  -UseBasicParsing `
  -TimeoutSec 30

$json=$resp.Content | ConvertFrom-Json

[pscustomobject]@{
    SessionId     = $sid
    StatusCode    = $resp.StatusCode
    ContentLength = $resp.Headers['Content-Length']
    ToolCount     = @($json.result.tools).Count
    ToolNames     = @($json.result.tools | Select-Object -ExpandProperty name)
}
```

Frisch verifizierte Referenz (2026-04-20):

- `StatusCode = 200`
- `Content-Length ≈ 43782`
- `ToolCount = 233` (variiert je nach Version)

## 5. Debug.txt mitlesen

Nach einer Probe immer `Debug.txt` gegenprüfen:

```powershell
Get-Content '.\Debug.txt' -Tail 200
```

Wichtige Zeilen für moderne POST-Probes:

- `POST /mcp HTTP/1.1`
- `K=ACCEPT V=application/json, text/event-stream`
- `K=MCP-PROTOCOL-VERSION V=2025-11-25`
- `INT_ProcessCommand: Handling as a REQUEST for method: initialize`
- `INT_ProcessCommand: Handling as a REQUEST for method: tools/list`
- `POST done (214 bytes...)` für `initialize`
- `POST done (43782 bytes...)` für `tools/list`

Wichtige Zeilen für SSE:

- `GET /mcp HTTP/1.1`
- `legacy SSE handshake`
- `Sent legacy endpoint event: /mcp?session_id=...`

## 6. API-Provider prüfen

SindByte hat einen eingebauten API-Provider auf Port 8091:

```powershell
Invoke-RestMethod -Uri 'http://127.0.0.1:8091/v1/models' -Method GET
```

Erwartet: Liste mit ~48 verfügbaren Modellen.

## 7. Aktuelles Verständnis

Der Server ist derzeit dual-mode:

- `GET /mcp` liefert SSE-Handshake (derzeit mit NullReferenceException, PROB-AUTO-001).
- `POST /mcp` liefert moderne JSON-MCP-Antworten und ist der funktionierende Pfad für Tool-Aufrufe.

Das bedeutet:

- Der Server ist nicht nur SSE.
- Der Server ist auch nicht nur reines Streamable HTTP.
- Für Agent-Integrationen: JSON-RPC POST mit `method = "tools/call"` ist der korrekte Weg.

## 8. Typische Fehlinterpretationen

- Ein erfolgreicher `initialize`-Body beweist noch nicht allein, dass die komplette Client-Integration gesund ist.
- Doppelte Requests bedeuten nicht automatisch dieselbe Session. Session-ID und Request-Line immer mitprüfen.
- Wenn `Debug.txt` bei `MCP-SESSION-ID` etwas wie `System.String[]` loggt, ist das ein Hinweis auf Header-Parsing oder Logging-Anomalien.
- Ein 401 von LM Studio (`:1234/v1/models`) ist normal — der Token-geschützte Endpunkt erfordert Authentifizierung. Interne Agent-Channels umgehen dies.

## 9. Nicht tun

- Keine VS-Code- oder Cline-Konfiguration ändern, nur um den Server lokal zu prüfen.
- Keine Aussagen wie "alles grün" machen, ohne frische HTTP-Probe und `Debug.txt`-Abgleich.
- Keine `DECLARE`-Workarounds für interne PB-Routinen einführen. Für Diagnosen hier ist das nicht nötig.
