DE EN
30-Min-Gespräch buchen
Zurück zum Blog

KI-Patterns

C#/.NET MCP Server Demo

Das Model Context Protocol (MCP) von Anthropic revolutioniert gerade die Integration von AI-Modellen mit externen Tools und Datenquellen. Während die meisten verfügbaren Demo-Implementierungen auf Python oder TypeScript basieren, zeigt dieses C/.NET-

SvK von Sven von Känel 14 Min Lesezeit
  • KI
  • MCP
  • .NET
  • C#

MCP Support für verschiedene Hosts und AI Provider

Das Model Context Protocol (MCP) von Anthropic revolutioniert gerade die Integration von AI-Modellen mit externen Tools und Datenquellen. Während die meisten verfügbaren Demo-Implementierungen auf Python oder TypeScript basieren, zeigt dieses C#/.NET-Projekt, wie sich MCP elegant in das Microsoft-Ökosystem integrieren lässt.

Dieses Demo-Projekt beinhaltet eine vollständige MCP-Host-Implementierung in .NET 9.0, die sowohl kommerzielle AI-Provider wie OpenAI, Azure OpenAI und Ionos als auch lokale LLM-Lösungen über Ollama und LMStudio nahtlos einbindet. Die Architektur ermöglicht es Entwicklern, sowohl STDIO- als auch SSE-basierte MCP-Server zu erstellen und diese in verschiedene MCP Hosts einzubinden und dabei verschiedene AI-Providern zu nutzen.

Besonderheiten der C#/.NET-Implementierung:

  • Microsoft.Extensions.AI für einheitliche AI-Provider-Abstraktion

  • Dependency Injection nach bewährten .NET-Patterns

  • Entity Framework Core für datenbankgestützte Tools

  • OpenTelemetry für umfassende Observability

  • Docker Compose für containerisierte Bereitstellung

Projektüberblick

Was beinhaltet dieses Projekt?

Das evanto MCP Host System ist eine Demo-.NET-Anwendung, die das Model Context Protocol (MCP) implementiert, um eine einheitliche Schnittstelle zwischen AI-Chat-Providern und spezialisierten Geschäftstools zu schaffen. Es ermöglicht die nahtlose Integration zwischen mehreren AI-Providern (OpenAI, Azure, Ollama, etc.) und benutzerdefinierten Geschäftstools hier am Beispiel eines Support-Ticket-Managements und Support-Dokumentenverarbeitung.

Kernfähigkeiten

  • Multi-Provider AI-Integration: Unterstützung für OpenAI, Azure OpenAI, Ollama, LMStudio und Ionos

  • Support-Ticket-Management: Vollständige CRUD-Operationen für Support-Anfragen mit SQLite-Speicherung

  • Dokumentenvektorisierung: PDF-Verarbeitung und semantische Suche mit Qdrant-Vektordatenbank für Support-Dokumentations-PDFs

  • Interaktiver Chat-Client: Kommandozeilen-Interface für AI-Unterhaltungen mit Tool-Integration

  • Containerisierte Bereitstellung: Docker Compose Setup für einfache Bereitstellung und Skalierung

  • Umfassende Tests: Eingebautes MCP-Server-Test-Framework mit automatisierten Parametern

Zielgruppe

Dieses System ist für C#-Entwickler konzipiert, die:

  • AI-Fähigkeiten in ihre Anwendungen über Microsoft.Extensions.AI integrieren möchten

  • MCP-konforme Tools und Server erstellen möchten

  • Semantische Suche und Dokumentenverarbeitung implementieren möchten

  • Multi-Provider-AI-Chat-Systeme erstellen möchten

  • Containerisierte AI-Infrastruktur bereitstellen möchten

AI Entwicklersupport

Bestimmte Projektbestandteile, wie Vektorisierung und PDF Dokumentenanalyse wurden initial mit Claude Code erstellt und dann manuell bearbeitet. Die Anweisungen für die Coding AI sind in CLAUDE.md und CodingRules.md hinterlegt (siehe Github Repository).

Systemarchitektur

High-Level-Architektur

Die folgende Übersicht gruppiert die verschiedenen Projekte des Demosystems: 

┌─────────────────────────────────────────────────────────────────┐
│                    Evanto MCP Host System                       │
├─────────────────────────────────────────────────────────────────┤
│                     Applications Layer                          │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐  │
│  │ cmd-mcp-host    │  │ cmd-vectorize   │  │ MCP Servers     │  │
│  │ (Interactive    │  │ (PDF            │  │ (SSE/STDIO)     │  │
│  │  Client)        │  │  Processing)    │  │                 │  │
│  └─────────────────┘  └─────────────────┘  └─────────────────┘  │
├─────────────────────────────────────────────────────────────────┤
│                    Core Libraries Layer                         │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐  │
│  │ Evanto.Mcp.Host │  │ Evanto.Mcp.Apps │  │ Evanto.Mcp.     │  │
│  │ (Factories &    │  │ (App Helpers)   │  │ Common          │  │
│  │  Testing)       │  │                 │  │ (Settings)      │  │
│  └─────────────────┘  └─────────────────┘  └─────────────────┘  │
├─────────────────────────────────────────────────────────────────┤
│                External Integration Layer                       │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐  │
│  │ Evanto.Mcp.     │  │ Evanto.Mcp.     │  │ Evanto.Mcp.     │  │
│  │ Embeddings      │  │ Pdfs            │  │ QdrantDB        │  │
│  │ (Multi-Provider)│  │ (iText7 Wrapper)│  │ (Vector DB)     │  │
│  └─────────────────┘  └─────────────────┘  └─────────────────┘  │
├─────────────────────────────────────────────────────────────────┤
│                     MCP Tools Layer                             │
│  ┌─────────────────┐  ┌─────────────────┐                       │
│  │ SupportWizard   │  │ SupportDocs     │                       │
│  │ (Ticket System) │  │ (Doc Search)    │                       │
│  └─────────────────┘  └─────────────────┘                       │
└─────────────────────────────────────────────────────────────────┘

Kernkomponenten

  1. Applications: Eigenständige ausführbare Programme

  2. Core Libraries: Geschäftslogik und Infrastruktur

  3. External Integration: Wrapper für externe Abhängigkeiten

  4. MCP Tools: Domänenspezifische Tool-Implementierungen

Technologie-Stack

  • .NET 9.0: Aktuelle C#-Features 

  • Microsoft.Extensions.AI: Einheitliche AI-Provider-Abstraktionen

  • Model Context Protocol: Offizielle MCP-Client/Server-Implementierung

  • Entity Framework Core: Datenbankabstraktion mit SQLite

  • OpenTelemetry: Observability und Telemetrie

  • Docker & Docker Compose: Containerisierung und Orchestrierung

  • iText7: PDF-Verarbeitung und Textextraktion

  • Qdrant: Vektordatenbank für semantische Suche

Design-Patterns

  • Factory Pattern: AI-Client und MCP-Client-Erstellung

  • Repository Pattern: Datenzugriff-Abstraktion

  • Dependency Injection: Microsoft.Extensions.DependencyInjection

  • Clean Architecture: Trennung der Zuständigkeiten über Schichten

  • Konfigurationsgesteuert: Umfassende Nutzung von appsettings.json

Projektstruktur

Übersicht über das Github-Projekt:

public-ai/
├── app/                                     # Eigenständige Anwendungen
│   ├── cmd-mcp-host/                        # Interaktiver MCP-Client
│   │   ├── Program.cs                       # Haupt-Einstiegspunkt
│   │   ├── appsettings.json                 # Client-Konfiguration
│   │   └── system-prompt.txt                # AI-System-Prompt
│   └── cmd-vectorize/                       # PDF-Vektorisierungs-Utility
│       ├── Program.cs                       # Haupt-Einstiegspunkt
│       ├── appsettings.json                 # Vektorisierungs-Einstellungen
│       └── Services/                        # Verarbeitungs-Services
├── lib/                                     # Kernbibliotheken
│   ├── Evanto.Mcp.Common/                   # Geteilte Utilities
│   │   ├── Settings/                        # Konfigurationsmodelle
│   │   ├── Mcp/                             # MCP-Basisklassen
│   │   └── Extensions/                      # Erweiterungsmethoden
│   ├── Evanto.Mcp.Host/                     # MCP-Hosting-Infrastruktur
│   │   ├── Factories/                       # Factory-Implementierungen
│   │   ├── Tests/                           # Test-Framework
│   │   └── Models/                          # Kernmodelle
│   ├── Evanto.Mcp.Apps/                     # Anwendungshelfer
│   │   ├── EvBaseAppHelper.cs               # Basis-Anwendungslogik
│   │   ├── EvCmdAppHelper.cs                # Kommando-App-Helfer
│   │   └── EvSrvAppHelper.cs                # Server-App-Helfer
│   ├── Evanto.Mcp.Embeddings/               # Text-Embedding-Services
│   │   ├── Factories/                       # Multi-Provider-Factory
│   │   ├── Services/                        # Embedding-Implementierungen
│   │   └── Extensions/                      # DI-Erweiterungen
│   ├── Evanto.Mcp.Pdfs/                     # PDF-Verarbeitung
│   │   ├── Services/                        # iText7-Wrapper
│   │   └── Extensions/                      # DI-Erweiterungen
│   ├── Evanto.Mcp.QdrantDB/                 # Vektordatenbank
│   │   ├── Repository/                      # Qdrant-Repository
│   │   ├── Models/                          # Dokumentmodelle
│   │   └── Extensions/                      # DI-Erweiterungen
│   ├── Evanto.Mcp.Tools.SupportWizard/      # Support-Ticket-System
│   │   ├── Tools/                           # MCP-Tool-Implementierungen
│   │   ├── Repository/                      # Datenbank-Repository
│   │   ├── Models/                          # Entity-Modelle
│   │   └── Context/                         # EF Core-Kontext
│   └── Evanto.Mcp.Tools.SupportDocs/        # Dokumentsuch-Tools
│       ├── Tools/                           # MCP-Tool-Implementierungen
│       └── Extensions/                      # DI-Erweiterungen
├── srv/                                     # MCP-Server
│   ├── sse-mcp-server/                      # SSE-basierter MCP-Server
│   │   ├── Program.cs                       # ASP.NET Core-App
│   │   ├── appsettings.json                 # Server-Konfiguration
│   │   └── Dockerfile                       # Container-Definition
│   └── stdio-mcp-server/                    # STDIO-basierter MCP-Server
│       ├── Program.cs                       # Konsolen-Host-App
│       ├── appsettings.json                 # Server-Konfiguration
│       └── Dockerfile                       # Container-Definition
├── db/                                      # Datenbankdateien
│   └── ev-supportwizard.db                  # SQLite-Datenbank (automatisch erstellt)
├── pdfs/                                    # PDF-Dokumente
│   └── processed_files.json                 # Datei-Tracking
├── run/                                     # Laufzeit-Konfigurationen
│   ├── sse/appsettings.json                 # SSE-Server-Konfig
│   └── stdio/appsettings.json               # STDIO-Server-Konfig
├── Directory.Packages.props                 # Zentrale Paket-Verwaltung
├── docker-compose.yaml                      # Container-Orchestrierung
├── .env.example                             # Umgebungsvariablen-Vorlage
└── CLAUDE.md                                # AI-Assistenten-Anweisungen

Kernbibliotheken

Evanto.Mcp.Host

Zweck: Kern-MCP-Hosting-Infrastruktur mit Factories und Test-Framework

Schlüsselkomponenten:

  • EvMcpClientFactory: Erstellt MCP-Clients für verschiedene Transport-Typen (STDIO, SSE, HTTP)

  • EvChatClientFactory: Erstellt AI-Chat-Clients für mehrere Provider

  • EvMcpServerTester: Umfassendes Test-Framework für MCP-Server und Tools

Verwendungsbeispiel:

// MCP-Client erstellen
var mcpClient = await mcpClientFactory.CreateAsync(serverSettings);

// Chat-Client erstellen
var chatClient = chatClientFactory.Create("OpenAI");

// MCP-Server testen
var testResult = await mcpTester.TestServerAsync(serverSettings);

Evanto.Mcp.Common

Zweck: Geteilte Konfigurationsmodelle, Einstellungen und Utilities

Schlüsselkomponenten:

  • EvHostAppSettings: Haupt-Anwendungskonfiguration

  • EvChatClientSettings: AI-Provider-Konfigurationen

  • EvMcpServerSettings: MCP-Server-Konfigurationen

  • EvMcpToolBase: Basisklasse für MCP-Tool-Implementierungen

Evanto.Mcp.Apps

Zweck: Anwendungshelfer-Services und geteilte Funktionalität

Schlüsselkomponenten:

  • EvBaseAppHelper: Gemeinsame Anwendungsinitialisierung

  • EvCmdAppHelper: Kommandozeilen-Anwendungshelfer

  • EvSrvAppHelper: Server-Anwendungshelfer

Evanto.Mcp.Embeddings

Zweck: Multi-Provider-Text-Embedding-Services mit Microsoft.Extensions.AI

Schlüsselfeatures:

  • Multi-Provider-Unterstützung: OpenAI, Azure, Ollama, LMStudio, Ionos

  • Einheitliche Schnittstelle: Einzige API unabhängig vom Provider

  • Performance-Optimierung: Eingebautes Caching und Rate-Limiting

  • Konfigurationsgesteuert: Provider-Auswahl über Einstellungen

Verwendungsbeispiel:

// Embedding-Service registrieren
services.AddEmbeddingService(settings);

// Embedding-Service verwenden
var embeddings = await embeddingService.GenerateEmbeddingsAsync(texts);

Evanto.Mcp.Pdfs

Zweck: PDF-Textextraktions-Services mit iText7

Schlüsselfeatures:

  • Enterprise-PDF-Verarbeitung: Behandelt komplexe PDF-Strukturen

  • Service-Abstraktion: Saubere Schnittstelle, die iText7-Komplexität verbirgt

  • Fehlerbehandlung: Robuste Behandlung korrupter PDFs

  • Performance-optimiert: Effiziente Textextraktion

Verwendungsbeispiel:

// PDF-Service registrieren
services.AddPdfTextExtractor();

// Text aus PDF extrahieren
var text = await pdfExtractor.ExtractTextAsync(pdfPath);

Evanto.Mcp.QdrantDB

Zweck: Einheitliches Repository für Qdrant-Vektordatenbank-Operationen

Schlüsselfeatures:

  • Einheitliches Dokumentmodell: Einzelnes EvDocument für alle Operationen

  • Erweiterte Suche: Vektor-, Text- und kombinierte Suchabfragen

  • Metadaten-Unterstützung: Umfangreiche Dokumentmetadaten und Filterung

  • Repository-Pattern: Saubere Datenzugriff-Abstraktion

Verwendungsbeispiel:

// Qdrant-Repository registrieren
services.AddQdrantDocumentRepository(settings);

// Dokument speichern
await repository.StoreDocumentAsync(document);

// Dokumente suchen
var results = await repository.SearchDocumentsAsync(query);

Evanto.Mcp.Tools.SupportWizard

Zweck: Support-Ticket-Management-System mit SQLite-Datenbank

Schlüsselfeatures:

  • Vollständige CRUD-Operationen: Erstellen, lesen, aktualisieren, löschen von Support-Anfragen

  • Benutzerverwaltung: Support-Mitarbeiter mit Themen-Zuweisungen

  • Status-Tracking: Ticket-Lebenszyklus-Management

  • Entity Framework Core: Code-First-Datenbankansatz

Demo-Datenbankschema (anpassbar):

-- Support-Anfragen
CREATE TABLE SupportRequests (
    Id UNIQUEIDENTIFIER PRIMARY KEY,
    CustomerEmail TEXT NOT NULL,
    CustomerName TEXT NOT NULL,
    Subject TEXT NOT NULL,
    Description TEXT NOT NULL,
    Status INTEGER NOT NULL,
    Priority INTEGER NOT NULL,
    CreatedAt DATETIME NOT NULL,
    UpdatedAt DATETIME NOT NULL
);

-- Benutzer
CREATE TABLE Users (
    Id UNIQUEIDENTIFIER PRIMARY KEY,
    Name TEXT NOT NULL,
    Email TEXT NOT NULL,
    Topic TEXT NOT NULL,
    IsActive BOOLEAN NOT NULL
);

Evanto.Mcp.Tools.SupportDocs

Zweck: Dokumentsuche und -verwaltung mit semantischer Ähnlichkeit

Schlüsselfeatures:

  • Semantische Suche: Dokumente nach Bedeutung finden, nicht nur nach Schlüsselwörtern

  • Dokumentenverwaltung: Dokumentation speichern und organisieren

  • Vektor-Integration: Nutzt Qdrant für hochperformante Suche

  • Multi-Provider-Embeddings: Flexible Embedding-Provider-Unterstützung

Anwendungen

cmd-mcp-host

Zweck: Interaktiver MCP-Client mit AI-Chat-Integration

Schlüsselfeatures:

  • Multi-Provider-Chat: Wechsel zwischen OpenAI, Azure, Ollama, etc.

  • MCP-Tool-Integration: Zugriff auf SupportWizard- und SupportDocs-Tools

  • Interaktive Oberfläche: Reiche Konsolen-Erfahrung mit Spectre.Console

  • Konfigurationsverwaltung: Unterstützt mehrere AI-Provider gleichzeitig

Verwendung:

# Interaktiven Client ausführen
dotnet run --project app/cmd-mcp-host

# Hilfe anzeigen
dotnet run --project app/cmd-mcp-host -- --help

# Verfügbare Provider auflisten
dotnet run --project app/cmd-mcp-host -- --list

# Server-Tests ausführen
dotnet run --project app/cmd-mcp-host -- --test

cmd-vectorize

Zweck: PDF-Verarbeitungs- und Vektorisierungs-Utility

Schlüsselfeatures:

  • Batch-PDF-Verarbeitung: Mehrere PDFs in einem Lauf verarbeiten

  • Text-Chunking: Konfigurierbare Chunk-Größen und Überlappung

  • Vektor-Speicherung: Embeddings in Qdrant-Datenbank speichern

  • Datei-Tracking: Wiederverarbeitung mit JSON-Tracking-Datei vermeiden

Verwendung:

# PDFs im konfigurierten Verzeichnis verarbeiten
dotnet run --project app/cmd-vectorize

# Konfiguration in appsettings.json:
{
    "PdfDirectory": "../../../../../pdfs",
    "TrackingFilePath": "../../../../../pdfs/processed_files.json"
}

MCP-Server

sse-mcp-server

Zweck: HTTP/SSE-basierter MCP-Server für Web-Integration

Schlüsselfeatures:

  • ASP.NET Core: Moderne Web-Server-Infrastruktur

  • Server-Sent Events: Echtzeit-Kommunikation

  • Health Checks: Eingebaute Endpoint-Überwachung

  • Docker-Unterstützung: Containerisierte Bereitstellung

stdio-mcp-server

Zweck: STDIO-basierter MCP-Server für Kommandozeilen-Integration

Schlüsselfeatures:

  • Standard I/O: Funktioniert mit jedem MCP-Client

  • Konsolen-Host: Leichtgewichtige Bereitstellung

  • Docker-Unterstützung: Container-basierte Ausführung

  • Interaktiver Modus: TTY-Unterstützung für Debugging

Voraussetzungen & Setup

Systemanforderungen

  • .NET 9.0 SDK oder später

  • Docker 20.10 oder später

  • Docker Compose 2.0 oder später

  • Git für Versionskontrolle

Erforderliche externe Services

  1. Qdrant-Vektordatenbank: Bereitgestellt über Docker Compose

  2. AI-Provider-API-Schlüssel: Mindestens einer von:

    • OpenAI-API-Schlüssel

    • Azure OpenAI-Zugangsdaten

    • Ollama (lokale Installation)

    • LMStudio (lokale Installation)

    • Ionos AI-API-Schlüssel

Entwicklungstools (empfohlen)

  • Visual Studio 2022 (aktualisiert) oder VS Code mit C#-Erweiterung

  • Docker Desktop für Container-Management

  • Postman oder ähnlich für API-Tests

  • DB Browser for SQLite für Datenbankinspektion

Installationsschritte

  1. Repository klonen:
git clone https://github.com/svkaenel/public-ai
cd public-ai
  1. .NET-Installation überprüfen:
dotnet --version
# Sollte 9.0.x oder später anzeigen
  1. Pakete wiederherstellen:
dotnet restore
  1. Lösung erstellen:
dotnet build
  1. Umgebungsvariablen einrichten (siehe Konfigurationsleitfaden)

Konfigurationsleitfaden

Umgebungsvariablen-Setup

Das System verwendet Umgebungsvariablen für API-Schlüssel und sensible Konfiguration. Dieser Ansatz hält Geheimnisse aus dem Quellcode heraus und unterstützt verschiedene Umgebungen.

Schritt 1: .env-Datei erstellen

# Beispieldatei kopieren
cp .env.example .env

# Mit Ihren Werten bearbeiten
nano .env  # oder Ihr bevorzugter Editor

Schritt 2: API-Schlüssel konfigurieren

.env-Datei mit Ihren API-Schlüsseln bearbeiten:

# OpenAI API-Schlüssel
OPENAI_API_KEY=your-openai-api-key-here

# Ionos AI API-Schlüssel (JWT-Token)
IONOS_API_KEY=your-ionos-jwt-token-here

# Azure AI API-Schlüssel
AZURE_API_KEY=your-azure-ai-api-key-here

# Azure OpenAI API-Schlüssel
AZUREOAI_API_KEY=your-azure-openai-api-key-here

# LMStudio API-Schlüssel (normalerweise leer für lokal)
LMSTUDIO_API_KEY=

# Ollama API-Schlüssel (normalerweise leer für lokal)
OLLAMA_API_KEY=

# Docker Compose-Konfiguration
SSE_PORT=5561
SSE_CONFIG_PATH=./run/sse/appsettings.json
STDIO_CONFIG_PATH=./run/stdio/appsettings.json

Schritt 3: Konfiguration überprüfen

Das System lädt automatisch Umgebungsvariablen in dieser Prioritätsreihenfolge:

  1. Kommandozeilen-Umgebungsvariablen (höchste Priorität)

  2. System-Umgebungsvariablen

  3. .env-Datei-Variablen

  4. appsettings.json-Werte (niedrigste Priorität)

AI-Provider-Konfiguration

Der ChatClients-Abschnitt in appsettings.json konfiguriert AI-Provider:

{
  "DefaultChatClient": "OpenAI",
  "ChatClients": [
    {
      "ProviderName": "OpenAI",
      "Endpoint": "https://api.openai.com/v1",
      "DefaultModel": "o4-mini",
      "AvailableModels": [
        "o4-mini",
        "gpt-4.1-mini",
        "gpt-4.1",
        "o1"
      ]
    },
    {
      "ProviderName": "Azure",
      "Endpoint": "https://your-resource.services.ai.azure.com/models",
      "DefaultModel": "DeepSeek-R1",
      "AvailableModels": [
        "DeepSeek-R1"
      ]
    },
    {
      "ProviderName": "Ollama",
      "Endpoint": "http://localhost:11434",
      "DefaultModel": "qwen3:14b",
      "AvailableModels": [
        "qwen3:4b",
        "qwen3:14b",
        "gemma3:12b"
      ]
    }
  ]
}

Datenbank-Konfiguration

SQLite-Datenbanken werden über Connection-Strings konfiguriert:

{
  "ConnectionStrings": {
    "SupportWizardDB": "Filename=db/ev-supportwizard.db"
  }
}

OpenTelemetry-Konfiguration

Observability und Telemetrie konfigurieren:

{
  "Telemetry": {
    "Enabled": true,
    "ServiceName": "cmd-mcp-host",
    "OtlpEndpoint": "http://localhost:4317",
    "EnableConsoleExporter": false,
    "EnableOtlpExporter": true,
    "LogSensitiveData": false,
    "ActivitySources": [
      "Microsoft.Extensions.AI"
    ]
  }
}

Docker-Setup & Bereitstellung

Docker Compose-Übersicht

Das System verwendet Docker Compose zur Orchestrierung mehrerer Services:

  • qdrantdb: Vektordatenbank für Dokumenten-Embeddings

  • aspire-dashboard: .NET Aspire-Dashboard für Telemetrie

  • sse-mcp-server: HTTP/SSE MCP-Server

  • stdio-mcp-server: STDIO MCP-Server

Umgebungsvorbereitung

  1. Umgebungsvariablen einrichten:
cp .env.example .env
# .env mit Ihren API-Schlüsseln bearbeiten
  1. Laufzeit-Konfigurationsverzeichnisse erstellen:
mkdir -p run/sse run/stdio
  1. Konfigurationsdateien kopieren (und anpassen!):
# Beispiel-Konfigurationen kopieren
cp app/cmd-mcp-host/appsettings.json run/sse/
cp app/cmd-mcp-host/appsettings.json run/stdio/

Schritt-für-Schritt-Bereitstellung

Schritt 1: Services erstellen und starten

# Alle Services erstellen und starten
docker-compose up -d

# Logs anzeigen
docker-compose logs -f

# Service-Status prüfen
docker-compose ps

MCP-Server separat erstellen (aus dem public-ai-Verzeichnis):

# SSE MCP-Server
docker build -f srv/sse-mcp-server/Dockerfile -t sse-mcp-server .

# STDIO MCP-Server  
docker build -f srv/stdio-mcp-server/Dockerfile -t stdio-mcp-server .

Schritt 2: Services überprüfen

# Prüfen, ob Qdrant läuft
curl http://localhost:6335/

# SSE MCP-Server prüfen
curl http://localhost:5561/

# Aspire-Dashboard prüfen
# Browser öffnen: http://localhost:4316

Schritt 3: Datenbank initialisieren

Die MCP-Server erstellen und migrieren die SQLite-Datenbank automatisch beim ersten Start.

Erste Schritte-Workflow

Folgen Sie diesen Schritten, um das System von Grund auf zum Laufen zu bringen:

Schritt 1: Klonen und Erstellen

# Repository klonen
git clone https://github.com/svkaenel/public-ai
cd public-ai

# Lösung erstellen
dotnet build

Schritt 2: Umgebung konfigurieren

# Umgebungsdatei erstellen
cp .env.example .env

# Mit Ihren API-Schlüsseln bearbeiten
nano .env

# Mindestens einen AI-Provider einstellen:
# OPENAI_API_KEY=your-api-key
# oder
# OLLAMA_API_KEY=  # für lokales Ollama

Schritt 3: Docker-Services starten

# Infrastruktur-Services starten
docker-compose up -d

# Überprüfen, ob Services laufen
docker-compose ps

# Logs prüfen, wenn nötig
docker-compose logs -f

Schritt 4: Vektordatenbank befüllen

# PDF-Dateien im pdfs/-Verzeichnis platzieren
cp /path/to/your/docs/*.pdf pdfs/

# Vektorisierung ausführen
dotnet run --project app/cmd-vectorize

# Verarbeitungsergebnisse prüfen
cat pdfs/processed_files.json

Schritt 5: MCP-Server testen

# Alle MCP-Server und Tools testen
dotnet run --project app/cmd-mcp-host -- --test

# Verfügbare Provider auflisten
dotnet run --project app/cmd-mcp-host -- --list

Schritt 6: Interaktiven Client ausführen

# Interaktiven Chat-Client starten
dotnet run --project app/cmd-mcp-host

# Beispiel-Unterhaltung:
# > Hallo, können Sie mir bei der Suche nach Dokumenten über Embeddings helfen?
# > Erstellen Sie ein neues Support-Ticket für Kunde john@example.com
# > Zeigen Sie mir alle Support-Tickets mit hoher Priorität

PDF-Vektorisierungs-Leitfaden

Zweck

Das cmd-vectorize-Utility verarbeitet PDF-Dokumente und konvertiert sie in Vektor-Embeddings für semantische Suche. Dies ermöglicht es dem SupportDocs-Tool, relevante Dokumente basierend auf Bedeutung zu finden, anstatt nur nach Schlüsselwörtern.

Konfiguration

app/cmd-vectorize/appsettings.json bearbeiten:

{
  "PdfDirectory": "../../../../../pdfs",
  "TrackingFilePath": "../../../../../pdfs/processed_files.json",
  "DefaultEmbeddingProvider": "OpenAI",
  "DefaultEmbeddingProviderAlt": "OllamaSharp",
  "EmbeddingProviders": [
    {
      "ProviderName": "OpenAI",
      "Endpoint": "https://api.openai.com/v1",
      "DefaultModel": "text-embedding-3-small",
      "EmbeddingDimensions": 1536
    },
    {
      "ProviderName": "Ollama",
      "Endpoint": "http://localhost:11434",
      "DefaultModel": "nomic-embed-text",
      "EmbeddingDimensions": 768
    }
  ],
  "Qdrant": {
    "QdrantEndpoint": "localhost",
    "CollectionName": "ev_support_documents",
    "QdrantPort": 6336,
    "VectorDimension": 1536
  }
}

Verwendungs-Workflow

Schritt 1: PDF-Dateien vorbereiten

# pdfs-Verzeichnis erstellen (falls nicht vorhanden)
mkdir -p pdfs

# Ihre PDF-Dokumente kopieren
cp /path/to/your/docs/*.pdf pdfs/

# Beispiel-Struktur:
# pdfs/
# ├── benutzerhandbuch.pdf
# ├── api-dokumentation.pdf
# ├── fehlerbehebung.pdf
# └── processed_files.json (automatisch generiert)

Schritt 2: Vektorisierung ausführen

# Alle PDFs im Verzeichnis verarbeiten
dotnet run --project app/cmd-vectorize

# Erwartete Ausgabe:
# [2024-01-01 10:00:00] Starte PDF-Vektorisierung...
# [2024-01-01 10:00:01] Verarbeite: benutzerhandbuch.pdf
# [2024-01-01 10:00:05] 1.234 Wörter extrahiert, 5 Chunks erstellt
# [2024-01-01 10:00:10] Embeddings generiert und in Qdrant gespeichert
# [2024-01-01 10:00:10] Verarbeite: api-dokumentation.pdf
# [2024-01-01 10:00:15] Überspringe (bereits verarbeitet): fehlerbehebung.pdf
# [2024-01-01 10:00:15] Vektorisierung abgeschlossen!

Schritt 3: Ergebnisse überprüfen

# Tracking-Datei prüfen
cat pdfs/processed_files.json

# Beispiel-Inhalt:
{
  "processed_files": [
    {
      "filename": "benutzerhandbuch.pdf",
      "processed_at": "2024-01-01T10:00:10Z",
      "chunk_count": 5,
      "word_count": 1234
    }
  ]
}

Verwenden des MCP-Host-Clients

Interaktives Chat-Interface

Die cmd-mcp-host-Anwendung bietet eine reichhaltige interaktive Erfahrung für AI-Unterhaltungen mit integrierten MCP-Tools.

Client starten

# Mit Standardkonfiguration ausführen
dotnet run --project app/cmd-mcp-host

# Verfügbare Optionen anzeigen
dotnet run --project app/cmd-mcp-host -- --help

# Konfigurierte Provider auflisten
dotnet run --project app/cmd-mcp-host -- --list

# MCP-Server vor dem Start testen
dotnet run --project app/cmd-mcp-host -- --test

Grundlegende Verwendung

Willkommen beim Evanto MCP Host Client
Aktueller Provider: OpenAI (o4-mini)
Verfügbare Tools: SupportWizard, SupportDocs
Geben Sie 'help' für Befehle ein, 'exit' zum Beenden

> Hallo, können Sie mir bei Support-Tickets helfen?

Tool-Integrations-Befehle

Der Client integriert automatisch mit MCP-Tools. Sie können natürliche Sprache verwenden, um mit ihnen zu interagieren:

# SupportWizard-Tool-Beispiele
> "Erstellen Sie ein neues Support-Ticket für Kunde john@example.com mit Betreff 'Anmeldeprobleme'"
> "Zeigen Sie mir alle Support-Tickets mit hoher Priorität"
> "Listen Sie alle Benutzer auf, die technische Probleme behandeln können"
> "Aktualisieren Sie Support-Ticket ID 123 auf gelöst"

# SupportDocs-Tool-Beispiele
> "Suchen Sie nach Dokumentation über Embeddings"
> "Finden Sie Informationen über API-Authentifizierung"
> "Schauen Sie nach Fehlerbehebungsleitfäden für Datenbankverbindungen"

Für weitere technische Details, vollständige Konfigurationsoptionen und erweiterte Verwendungsszenarien verweisen wir auf die vollständige README.md in unserem GitHub-Repository.

Das Projekt ist unter der MIT-Lizenz auf GitHub verfügbar: https://github.com/svkaenel/public-ai

Dieses C#/.NET MCP-Demo-Projekt zeigt, wie eine MCP-Integration im Microsoft-Ökosystem implementiert werden kann und bietet eine  Grundlage für eigene MCP-basierte Anwendungen.

VERWANDTE ARTIKEL

Drei verwandte Artikel.

NEWSLETTER

Vier bis sechs Mal im Jahr, kein Werbe-Lärm.

Ein Pattern, ein Case, eine Empfehlung. Anmeldung mit Double-Opt-In, jederzeit kündbar.

Mit der Anmeldung akzeptieren Sie unsere Datenschutzerklärung.