Picard MCP Server

Überblick

Picard MCP ist ein umfassendes Speicherverwaltungssystem, das auf dem Model Context Protocol (MCP) -Standard basiert. Es besteht aus zwei Hauptkomponenten: einem MCP-Server, der sichere Speicherspeicher- und -abrufdienste bereitstellt, und einer Django-Client-Anwendung, die die Integration mit dem MCP-Server demonstriert. Das System ermöglicht Benutzern das Speichern, Abrufen und Verwalten ihrer Speicher unter Kontrolle der Zugriffsberechtigungen und ermöglicht semantische Suche und KI-gestützte Abfragen basierend auf gespeicherten Speicherdaten.

MCP-Konformität

Diese Implementierung folgt dem Model Context Protocol-Standard, der LLM-Anwendungen eine standardisierte Interaktion mit dem Server ermöglicht. Der MCP-Server stellt Folgendes bereit:

• Ressourcen : Nur-Lese-Endpunkte, die Daten an LLMs (Speicherinhalte) liefern

• Tools : Funktionale Endpunkte, die Aktionen ausführen (Speichererstellung, Aktualisierungen, Abfragen)

• Authentifizierung : OAuth 2.0-Implementierung für sicheren Zugriff auf geschützte Ressourcen

Schlüsselkomponenten

1. MCP-Server : Eine FastAPI-basierte Implementierung des Model Context Protocol, die Folgendes bietet:

   • OAuth 2.0-Authentifizierung und -Autorisierung mit PKCE-Unterstützung

   • Speicher mit Vektoreinbettungen

   • Berechtigungsbasierte Speicherzugriffskontrolle

   • LLM-Integration für speicherbasierte Abfragen

2. Django-Client : Eine Webanwendung, die die Integration mit dem MCP-Server demonstriert:

   • Benutzerregistrierung und Authentifizierung

   • OAuth 2.0-Clientimplementierung

   • Benutzeroberfläche zum Erstellen, Abrufen und Verwalten von Speicher

   • Persona-basierte Abfrageschnittstelle

Systemarchitektur

Gesamtarchitektur

Das Picard MCP-System folgt einer Client-Server-Architektur mit den folgenden Komponenten:

1. MCP-Server : Zentraler Backend-Dienst, der Speicherspeicherung, -abruf und KI-Operationen übernimmt

   • Erstellt mit FastAPI (FastMCP) für hohe Leistung und asynchrone Unterstützung

   • Verwendet PostgreSQL mit pgvector-Erweiterung für Vektorspeicherung und semantische Suche

   • Implementiert Datenmodelle für Benutzer, Erinnerungen (mit Vektoreinbettungen), OAuth-Clients und Token

   • Verwendet SQLAlchemy ORM mit Alembic-Migrationen für die Datenbankverwaltung

   • Implementiert OAuth 2.0 für sichere Authentifizierung und Autorisierung

   • Integriert mit OpenAI API für Speichereinbettungen (text-embedding-3-small)

   • Verwendet LangChain für LLM-Operationen, sofern verfügbar

   • Bietet sowohl zustandsbehaftete als auch zustandslose Betriebsmodi

   • Unterstützt streambaren HTTP-Transport für bessere Skalierbarkeit

2. Django-Client : Webanwendung, die die Integration mit dem MCP-Server demonstriert

   • Bietet Benutzerregistrierung, Authentifizierung und Profilverwaltung

   • Implementiert OAuth 2.0-Client für die sichere Kommunikation mit dem MCP-Server

   • Bietet eine benutzerfreundliche Oberfläche für Speicherverwaltung und Abfragen

   • Verwendet eine eigene PostgreSQL-Datenbank, getrennt vom MCP-Server

3. Docker-Infrastruktur : Containerisierte Bereitstellung für einfache Einrichtung und Skalierung

   • Separate Container für MCP-Server (Port 8001), Django-Client (Port 8000) und PostgreSQL-Datenbanken

   • Konfiguriertes Netzwerk für sichere Kommunikation zwischen Containern

   • Volume-Mounting für dauerhafte Datenspeicherung

   • Kompatibel sowohl mit der lokalen Docker-Bereitstellung als auch mit der Render-Cloud-Bereitstellung

Authentifizierungsansätze

Das System bietet zwei Hauptauthentifizierungsansätze:

1. Direktverbindung mit User Context Token Flow (empfohlen)

Dieser vereinfachte Ansatz ermöglicht es Benutzern, sich nur einmal beim Django-Client zu authentifizieren, wodurch die Notwendigkeit einer separaten MCP-Serverauthentifizierung vermieden wird:

1. Kundenregistrierung :

   • Der Django-Client registriert sich beim MCP-Server über den Endpunkt /api/admin/clients/register

   • Die Registrierung erfordert eine Administratorauthentifizierung und umfasst den Clientnamen, Umleitungs-URIs und die angeforderten Bereiche.

   • Der MCP-Server gibt eine UUID-basierte Client-ID und ein kryptografisch sicheres Client-Geheimnis aus

   • Client-Anmeldeinformationen sollten sicher gespeichert und niemals im clientseitigen Code offengelegt werden

2. Ablauf der Benutzerauthentifizierung :

   • Der Benutzer authentifiziert sich nur mit dem Django-Client

   • Wenn der Benutzer eine Verbindung zum MCP-Server initiiert, sendet der Django-Client eine serverseitige Anfrage an den Endpunkt /api/user-tokens/user-token des MCP.

   • Die Anfrage umfasst:

     • Client-Anmeldeinformationen (Client-ID und Client-Geheimnis)

     • Benutzerinformationen (Benutzername und E-Mail)

     • Option zum Erstellen eines Benutzers, falls nicht vorhanden

   • Der MCP-Server überprüft die Client-Anmeldeinformationen und findet oder erstellt einen entsprechenden Benutzer

   • Der MCP-Server stellt Zugriffs- und Aktualisierungstoken für den Benutzer aus

   • Der Django-Client speichert diese Token sicher und verwendet sie für API-Anfragen

3. API-Zugriff :

   • Der Client schließt das Zugriffstoken in den Autorisierungsheader ( Authorization: Bearer {token} ) für alle API-Anfragen ein

   • Der MCP-Server validiert die Token-Signatur, das Ablaufdatum und die Zielgruppenansprüche

   • Der MCP-Server erzwingt bereichsbasierte Berechtigungen für jeden Endpunkt

   • Wenn das Zugriffstoken abläuft, verwendet der Client das Aktualisierungstoken, um ein neues zu erhalten

4. Sicherheitsfunktionen :

   • Nur vertrauliche Clients können diese Methode verwenden, wodurch Server-zu-Server-Sicherheit gewährleistet wird

   • Die Client-Anmeldeinformationen werden bei jeder Token-Anforderung überprüft

   • Token werden nach der Verwendung auf die schwarze Liste gesetzt, um Replay-Angriffe zu verhindern

   • Rotation der Aktualisierungstoken: Jede Verwendung generiert ein neues Aktualisierungstoken und macht das alte ungültig

2. Standard-OAuth 2.0-Autorisierungscode-Flow mit PKCE (Legacy)

Das System unterstützt außerdem den standardmäßigen OAuth 2.0-Autorisierungscode-Flow mit PKCE für erhöhte Sicherheit gemäß den Standards RFC 6749 und RFC 7636. Dieser Ansatz erfordert die Authentifizierung von Benutzern sowohl beim Client als auch beim MCP-Server:

1. Autorisierungsablauf :

   • Der Benutzer initiiert die Anmeldung über den Django-Client

   • Der Client generiert einen kryptografisch sicheren state zum CSRF-Schutz

   • Der Client generiert einen zufälligen PKCE- code_verifier und leitet code_challenge mithilfe von SHA-256 ab.

   • Der Client leitet zum /authorize -Endpunkt des MCP-Servers weiter mit:

     • response_type=code

     • client_id (UUID-Format)

     • redirect_uri

     • scope (durch Leerzeichen getrennte Liste, z. B. memories:read memories:write )

     • state (für CSRF-Schutz)

     • PKCE-Parameter ( code_challenge und code_challenge_method=S256 )

   • Der MCP-Server authentifiziert den Benutzer (sofern nicht bereits authentifiziert)

   • Der MCP-Server validiert alle Parameter und leitet mit einem kurzlebigen Autorisierungscode zurück zum Client.

2. Token-Austausch :

   • Der Client überprüft, ob der zurückgegebene state mit dem in der Autorisierungsanfrage gesendeten übereinstimmt.

   • Der Client tauscht den Autorisierungscode gegen Zugriffs- und Aktualisierungstoken über /token -Endpunkt aus

   • Der MCP-Server stellt ein JWT-Zugriffstoken, ein Aktualisierungstoken, eine Ablaufzeit und gewährte Bereiche aus

3. API-Zugriff :

   • Wie beim Direct Connect-Ansatz

Datenbankmodelle

Der MCP-Server verwendet SQLAlchemy ORM mit den folgenden Schlüsselmodellen:

1. Benutzermodell :

   • Speichert Benutzerinformationen mit E-Mail, Benutzername und gehashtem Passwort

   • Enthält boolesche Flags für den Kontostatus (is_active, is_superuser)

   • Durch eine Eins-zu-viele-Beziehung mit Erinnerungen verknüpft

2. Speichermodell mit Vektorspeicher :

   • Verwendet die pgvector-Erweiterung zum Speichern und Abfragen von Vektoreinbettungen (1536 Dimensionen)

   • Unterstützt Textinhalte mit optionaler Verschlüsselung

   • Beinhaltet Berechtigungskontrollen (privat/öffentlich)

   • Unterstützt Ablaufdaten für zeitlich begrenzte Erinnerungen

   • Mit Benutzern durch Fremdschlüsselbeziehung verknüpft

3. OAuth-Modelle :

   • OAuthClient : Speichert Client-Anwendungsdetails, einschließlich Client-ID, Client-Geheimnis, Umleitungs-URIs und autorisierte Bereiche

   • AuthorizationCode : Verwaltet temporäre Autorisierungscodes mit PKCE-Unterstützung

   • Token : Speichert Zugriffs- und Aktualisierungstoken mit Ablaufverfolgung

Das System verwendet Alembic für Datenbankmigrationen und gewährleistet so Schemaversionierung und einfache Updates.

Speicherverwaltungssystem

Die Kernfunktionalität von Picard MCP dreht sich um die Speicherverwaltung mit den folgenden Komponenten:

1. Speicherkapazität :

   • Erinnerungen werden als Text mit zugehörigen Metadaten gespeichert

   • Vektor-Einbettungen (unter Verwendung des Text-Embedding-3-Small-Modells) ermöglichen semantische Suchfunktionen

   • Berechtigungen steuern, wer auf jeden Speicher zugreifen kann

   • Zeitstempel protokollieren Erstellung, Änderung und Ablauf

   • Der gespeicherte Text wird im Ruhezustand verschlüsselt, während die Metadaten durchsuchbar bleiben

   • Alle Bezeichner verwenden zur Skalierbarkeit das UUID-Format anstelle von sequentiellen Ganzzahlen

   • Jeder Speicher wird mithilfe des Einbettungsmodells von OpenAI in eine Vektoreinbettung umgewandelt

   • Einbettungen ermöglichen semantische Suche und Ähnlichkeitsabgleich

   • PostgreSQL mit pgvector-Erweiterung bietet effiziente Vektorspeicherung und -abfrage

2. Berechtigungsverwaltung :

   • Jeder Speicher hat eine Berechtigungsstufe (privat oder öffentlich)

   • Private Erinnerungen sind nur für den Besitzer zugänglich

   • Öffentliche Erinnerungen können von anderen Benutzern für Persona-Abfragen abgerufen werden

   • Das System ist so konzipiert, dass es für zukünftige Berechtigungstypen erweiterbar ist (z. B. für die statistische/aggregierte Verwendung).

   • Auf freigegebene Erinnerungen können bestimmte Benutzer oder Gruppen zugreifen

   • Berechtigungen können vom Speicherbesitzer jederzeit geändert werden

3. Gedächtnisabruf :

   • Benutzer können ihre eigenen Erinnerungen mit Filter- und Sortieroptionen abrufen

   • Die semantische Suche ermöglicht das Auffinden von Erinnerungen anhand ihrer Bedeutung, nicht nur anhand von Schlüsselwörtern

   • Vektorähnlichkeit (Kosinus) ermöglicht das Auffinden verwandter Erinnerungen in der gesamten Datenbank

   • Die Top-N-ähnlichsten Erinnerungen werden basierend auf der Abfragerelevanz zurückgegeben

   • Berechtigungsprüfungen stellen sicher, dass Benutzer nur auf autorisierte Speicher zugreifen

4. LLM-Integration :

   • Erinnerungen können als Kontext für LLM-Abfragen verwendet werden

   • Benutzer können Personas basierend auf ihren öffentlichen Erinnerungen erstellen

   • Andere Benutzer können diese Personas abfragen, um Antworten zu erhalten, die auf den Erinnerungen basieren

   • Das System übernimmt automatisch Kontextmanagement und Prompt Engineering

Hauptmerkmale

MCP-Serverfunktionen

• OAuth 2.0-Authentifizierung :

  • Autorisierungscode-Fluss mit PKCE für erhöhte Sicherheit

  • Umfangsbasiertes Berechtigungssystem ( memories:read , memories:write , memories:admin )

  • Tokenverwaltung mit Aktualisierungstoken-Unterstützung

  • Kundenregistrierung und -verwaltung

• Speicherverwaltung :

  • Erinnerungen erstellen, lesen, aktualisieren und löschen

  • Vektoreinbettung für die semantische Suche

  • Berechtigungsbasierte Zugriffskontrolle

  • Stapelverarbeitung für effiziente Speicherverwaltung

• Benutzerverwaltung :

  • Benutzerregistrierung und Authentifizierung

  • Profilverwaltung und -einstellungen

  • Aktivitätsverfolgung und -analyse

  • Administratorkontrollen für die Systemverwaltung

• KI-Integration :

  • OpenAI-API-Integration für Einbettungen und LLM-Abfragen

  • Persona-Erstellung basierend auf Benutzererinnerungen

  • Kontextbezogene Abfrageverarbeitung

  • Anpassbare KI-Parameter und -Einstellungen

Django-Clientfunktionen

• Benutzeroberfläche :

  • Klares, ansprechendes Design für Desktop und Mobilgeräte

  • Intuitive Speicherverwaltungsoberfläche

  • Erweiterte Such- und Filteroptionen

  • Persona-Erstellungs- und Abfrageschnittstelle

• OAuth-Client-Implementierung :

  • Sichere Token-Speicherung und -Verwaltung

  • Automatische Token-Aktualisierung

  • Umfangsbasierte Funktionsverfügbarkeit

  • Fehlerbehandlung und Wiederherstellung

• Speichertools :

  • Speichererstellung mit Rich-Text-Unterstützung

  • Batch-Import und -Export

  • Berechtigungsverwaltungsschnittstelle

  • Tagging und Kategorisierung

MCP-Schnittstelle

MCP-Ressourcen

• Speicherressource : memories://{memory_id}

  • Gibt den Inhalt eines bestimmten Speichers mit Berechtigungsprüfungen zurück

  • Parameter: memory_id (UUID)

  • Antwort: Speicherinhalt mit Metadaten

• Benutzererinnerungsressource : users://{user_id}/memories

  • Gibt eine Liste von Erinnerungen für einen bestimmten Benutzer mit Berechtigungsprüfungen zurück

  • Parameter: Benutzer-ID (UUID), optionale Filter

  • Antwort: Liste der Speicherzusammenfassungen

MCP-Tools

• Erinnerungstool übermitteln : Erstellt eine neue Erinnerung

  • Parameter: Text (Zeichenfolge), Berechtigung (Zeichenfolge)

  • Rückgabe: Erstellte Speicherdetails mit UUID

• Update Memory Tool : Aktualisiert einen vorhandenen Speicher

  • Parameter: memory_id (UUID), Text (Zeichenfolge)

  • Rückgabe: Aktualisierte Speicherdetails

• Werkzeug „Speicher löschen“ : Löscht einen Speicher

  • Parameter: memory_id (UUID)

  • Rückgabe: Erfolgsbestätigung

• Query Memory Tool : Führt eine semantische Suche in Erinnerungen durch

  • Parameter: Abfrage (Zeichenfolge), Limit (Ganzzahl)

  • Rückgabe: Liste relevanter Erinnerungen

• Benutzer abfragen : Fragt die Persona eines Benutzers anhand von Erinnerungen ab

  • Parameter: Benutzer-ID (UUID), Abfrage (Zeichenfolge)

  • Rückgabe: Antwort basierend auf den Erinnerungen des Benutzers

API-Endpunkte

OAuth-Endpunkte

• Kundenregistrierung : /register

  • Methode: POST

  • Beschreibung: Einen neuen OAuth-Client registrieren

  • Anfrage: Clientdetails (ID, Geheimnis, Umleitungs-URIs, Bereiche)

  • Antwort: Client-Anmeldeinformationen und Registrierungsinformationen

• Autorisierung : /authorize

  • Methode: GET

  • Beschreibung: OAuth-Autorisierungsablauf initiieren

  • Parameter: Antworttyp, Client-ID, Umleitungs-URI, Bereich, Status, Code-Challenge, Code-Challenge-Methode

  • Antwort: Weiterleitung zum Client mit Autorisierungscode

• Token-Austausch : /token

  • Methode: POST

  • Beschreibung: Autorisierungscode für Token austauschen

  • Anfrage: grant_type, code, redirect_uri, client_id, client_secret, code_verifier

  • Antwort: Zugriffstoken, Aktualisierungstoken, Ablauf und Umfangsinformationen

Speicherendpunkte

• Erinnerungen abrufen : /api/tools (Tool: get_memories )

  • Methode: POST

  • Beschreibung: Erinnerungen abrufen mit optionaler Filterung

  • Authentifizierung: Bearer-Token

  • Anfrage: Optionale Filterparameter (Benutzer-ID, Berechtigung, Ablaufstatus)

  • Antwort: Liste der für den Benutzer zugänglichen Speicher

  • Beispielanfrage:

    { "tool": "get_memories", "data": { "user_id": "550e8400-e29b-41d4-a716-446655440000", "permission": "private" } }

• Speicher übermitteln : /api/tools (Tool: submit_memory )

  • Methode: POST

  • Beschreibung: Erstellen Sie eine neue Erinnerung

  • Authentifizierung: Bearer-Token

  • Anfrage: Speichertext, Berechtigungsstufe und Ablaufdatum (ISO 8601-Format, z. B. „2025-12-31T23:59:59Z“)

  • Antwort: Erstellte Speicherdetails einschließlich UUID-Kennung

  • Beispielanfrage:

    { "tool": "submit_memory", "data": { "text": "This is my memory content", "permission": "private" } }

• Erinnerungen abrufen : /api/tools (Tool: retrieve_memories )

  • Methode: POST

  • Beschreibung: Alle Erinnerungen für den authentifizierten Benutzer abrufen

  • Authentifizierung: Bearer-Token

  • Antwort: Liste der Speicherobjekte mit UUID-Kennungen

  • Beispielanfrage:

    { "tool": "retrieve_memories", "data": {} }

• Speicher aktualisieren : /api/tools (Tool: update_memory )

  • Methode: POST

  • Beschreibung: Aktualisieren eines vorhandenen Speichers

  • Authentifizierung: Bearer-Token

  • Anfrage: Speicher-ID, aktualisierter Inhalt und optional aktualisiertes Ablaufdatum (ISO 8601-Format)

  • Antwort: Speicherdetails aktualisiert

  • Beispielanfrage:

    { "tool": "update_memory", "data": { "memory_id": "550e8400-e29b-41d4-a716-446655440000", "text": "Updated memory content", "expiration_date": "2026-01-01T00:00:00Z" } }

• Berechtigungen ändern : /api/tools (Tool: modify_permissions )

  • Methode: POST

  • Beschreibung: Speicherberechtigungsstufe aktualisieren

  • Authentifizierung: Bearer-Token

  • Anfrage: Speicher-UUID und neue Berechtigungsstufe

  • Antwort: Speicherdetails aktualisiert

  • Beispielanfrage:

    { "tool": "modify_permissions", "data": { "memory_id": "550e8400-e29b-41d4-a716-446655440000", "permission": "public" } }

• Abfragebenutzer : /api/tools (Tool: query_user )

  • Methode: POST

  • Beschreibung: Abfrage der Persona eines Benutzers basierend auf Erinnerungen (öffentlich für andere Benutzer, öffentlich+privat für einen selbst)

  • Authentifizierung: Bearer-Token

  • Anfrage: Benutzer-UUID und Abfrageaufforderung

  • Antwort: JSON mit nicht abgelaufenen Speichern, entweder alle gültigen Speicher oder die Top-N, die der Abfrage am ähnlichsten sind

  • Antwort: KI-generierte Antwort basierend auf den Erinnerungen des Benutzers

  • Beispielanfrage:

    { "tool": "query_user", "data": { "user_id": "550e8400-e29b-41d4-a716-446655440000", "prompt": "What are your thoughts on artificial intelligence?" } }

Einrichtung und Bereitstellung

Voraussetzungen

• Docker und Docker Compose

• Python 3.10+

• OpenAI-API-Schlüssel

Vollständiges Setup-Handbuch

1. Klonen Sie das Repository:

   git clone https://github.com/yourusername/picard_mcp.git cd picard_mcp

2. Erstellen Sie Umgebungsdateien für beide Komponenten:

   # For MCP server cp mcp_server/.env.example mcp_server/.env # For Django client cp django_client/.env.example django_client/.env

3. Bearbeiten Sie die Umgebungsdateien, um Ihre Konfiguration festzulegen:

   • In mcp_server/.env : Legen Sie Ihre Datenbankanmeldeinformationen, den OpenAI-API-Schlüssel und die Administratoranmeldeinformationen fest

   • In django_client/.env : Legen Sie Ihre Datenbankanmeldeinformationen und OAuth-Einstellungen fest

4. Starten Sie die Dienste mit Docker Compose:

   docker-compose up -d

   Dadurch werden die folgenden Dienste gestartet:

   • db-mcp : PostgreSQL-Datenbank für den MCP-Server

   • db-django : PostgreSQL-Datenbank für den Django-Client

   • mcp_server : MCP-Server läuft auf http://localhost:8001

   • django_client : Django-Client, der auf http://localhost:8000 ausgeführt wird

5. Erstellen Sie einen Administratorbenutzer für den MCP-Server:

   docker-compose exec mcp_server python scripts/create_admin_user.py

   Dadurch wird ein Administratorbenutzer mit den in Ihren Umgebungsvariablen angegebenen Anmeldeinformationen erstellt.

6. Registrieren Sie den Django-Client beim MCP-Server:

   docker-compose exec django_client python register_oauth_client.py

   Dadurch wird der Django-Client beim MCP-Server registriert und die .env Datei des Django-Clients mit den Client-Anmeldeinformationen aktualisiert.

7. Greifen Sie auf die Anwendungen zu:

   • MCP-Server: http://localhost:8001

   • Django-Client: http://localhost:8000

8. Erstellen Sie im Django-Client ein Benutzerkonto und beginnen Sie mit der Verwendung der Anwendung.

Erste Tests

Um zu überprüfen, ob Ihr Setup ordnungsgemäß funktioniert, führen Sie die folgenden Tests aus:

1. MCP-Servertests :

   docker-compose exec mcp_server python -m pytest

   Dadurch werden alle Unit-Tests für den MCP-Server ausgeführt, einschließlich OAuth-Endpunkte, Administratorfunktionen und Speicherverwaltung.

2. Django-Client-Tests :

   docker-compose exec django_client python manage.py test

   Dadurch wird die Integration des Django-Clients mit dem MCP-Server getestet.

3. Manuelles Testen :

   • Erstellen Sie ein Benutzerkonto im Django-Client unter http://localhost:8000/register

   • Melden Sie sich an und stellen Sie über OAuth eine Verbindung zum MCP-Server her

   • Erinnerungen erstellen, abrufen und verwalten

   • Testen Sie die semantische Suchfunktion

Sicherheitsüberlegungen

Datenschutz

• Der Speichertextinhalt wird im Ruhezustand mit der symmetrischen Fernet-Verschlüsselung von Python (AES-128 im CBC-Modus mit PKCS7-Padding) verschlüsselt, während die Metadaten durchsuchbar bleiben

• Personenbezogene Daten (PII) werden durch Textfeldverschlüsselung geschützt

• Zugriffstoken haben eine Ablaufzeit von einer Stunde, um die Gefährdung zu begrenzen

• Aktualisierungstoken sind langlebig, verwenden aber Rotation: Jede Verwendung generiert ein neues Aktualisierungstoken und macht das alte ungültig

• OAuth-Token werden sicher in der PostgreSQL-Datenbank des Django-Clients gespeichert

UUID-Verwendung

Alle Bezeichner im System verwenden aus mehreren Gründen das UUID v4-Format anstelle von fortlaufenden Ganzzahlen:

1. Sicherheit : UUIDs geben keine Systeminformationen oder Datensatzzahlen preis

2. Skalierbarkeit : UUIDs können ohne Datenbankkoordination generiert werden, was verteilte Systeme ermöglicht

3. Nicht-Erratbarkeit : UUIDs sind praktisch unmöglich zu erraten, was Enumerationsangriffe verhindert

4. Konsistenz : Die Verwendung von UUIDs im gesamten System vereinfacht die Integration mit anderen Diensten

Alle IDs in der API (Benutzer-ID, Speicher-ID, Client-ID usw.) müssen im UUID-Format vorliegen.

Bewährte Methoden für OAuth

• Die gesamte OAuth-Kommunikation muss in Produktionsumgebungen HTTPS verwenden.

• Autorisierungscodes sind nur einmalig verwendbar und von kurzer Dauer (max. 5 Minuten).

• PKCE ist für alle Clients, auch vertrauliche, zur umfassenden Verteidigung erforderlich

• Aktualisierungstoken sind langlebig, können aber von Benutzern oder Administratoren widerrufen werden

• Das System führt eine Token-Blacklist für widerrufene Token

Dokumentation

API-Dokumentation

Der MCP-Server enthält Swagger/OpenAPI-Dokumentation für alle Endpunkte:

• Greifen Sie bei laufendem Server unter /docs auf die Swagger-Benutzeroberfläche zu

• Die OpenAPI-Spezifikation ist unter /openapi.json verfügbar.

• Alle API-Endpunkte sind vollständig mit Anfrage-/Antwortschemata und Beispielen dokumentiert

Zusätzliche Dokumentationsdateien

• TESTING.md : Umfassender Leitfaden zum Testen der Anwendung

  • Beschreibt alle implementierten Tests und deren Zweck

  • Anweisungen zum Ausführen von Tests lokal und in CI/CD

  • Dokumentiert die Testabdeckung und identifiziert Bereiche, die zusätzliche Tests erfordern

• DEBUGGING.md : Verfolgt Probleme und deren Lösungen

  • Protokolliert bekannte Fehler, die noch nicht behoben wurden

  • Dokumentiert zuvor behobene Fehler und deren Lösungen

  • Bietet Anleitungen zur Fehlerbehebung bei häufigen Problemen

• PLANNING.md : Verfolgt die Aufschlüsselung der Aufgaben, die zur Implementierung der Site erforderlich sind

  • Listet die Aufgaben und Unteraufgaben auf, die zur Implementierung der Site erforderlich sind

  • Dokumentiert die Erledigung einer Aufgabe mit einem Kontrollkästchen

Einsatz

Dieses Projekt enthält eine docker-compose.yml für die lokale Entwicklung und render.yaml Blaupause für die Bereitstellung in Render. Dieselbe Codebasis funktioniert sowohl lokal in Docker-Containern als auch bei der Bereitstellung in Render-Cloud-Diensten.

MCP-Serverbereitstellung

1. Docker-Bereitstellung (für die Produktion empfohlen):

   docker-compose up -d

   Die Docker Compose-Konfiguration umfasst:

   • Netzwerkkonfiguration für die Kommunikation zwischen Containern

   • Volume-Mounts für die dauerhafte Datenspeicherung

   • Umgebungsvariablenkonfiguration aus .env-Dateien

   • Portzuordnungen (8000 für Django-Client, 8001 für MCP-Server)

   • Integritätsprüfungen für Dienstabhängigkeiten

2. Render Cloud-Bereitstellung : Verwenden Sie die enthaltene render.yaml Blaupause zur Bereitstellung in Render.

Lizenz

MIT