Du hast eine Access-Datenbank. Vielleicht eine Instandhaltungslösung, eine Kundenverwaltung, ein Auftragsmanagement. Die Daten sind gut, die Formulare funktionieren, die Berichte laufen. Aber jetzt hörst du überall „KI“ – und fragst dich: Wie kriege ich meine Access-Daten in Claude rein?
Die kurze Antwort: Nicht Access in Claude reinstopfen. Sondern Claude beibringen, mit deiner Datenbank zu sprechen. Die Technologie dafür heißt MCP – Model Context Protocol. Und als Access-Entwickler bist du näher dran, als du denkst.
Was du nach diesem Artikel kannst
Du verstehst, wie die Brücke zwischen Access und Claude funktioniert – technisch, nicht nur als Buzzword. Du kennst die Architektur, die Bausteine und die Stolpersteine. Und du hast ein konkretes Minimalbeispiel, das du in ein paar Stunden auf deinem Rechner nachbauen kannst.
Keine Cloud-Migration. Kein Azure. Kein Umstieg auf eine andere Datenbank. Deine .accdb bleibt, wo sie ist.
Warum nicht einfach Copy & Paste?
Der naheliegende Gedanke: Ich exportiere meine Daten als CSV oder Text, paste sie in den Claude-Chat und stelle Fragen dazu. Das funktioniert – für einmalige Analysen. Aber es hat drei Probleme:
Erstens: Du arbeitest mit einem Snapshot. Sobald sich ein Datensatz ändert, ist dein Chat veraltet.
Zweitens: Du kannst nicht zurückschreiben. Claude kann dir sagen, welche Wartung überfällig ist – aber den Status auf „erledigt“ setzen? Geht so nicht.
Drittens: Es skaliert nicht. Bei 50 Datensätzen klappt Copy & Paste. Bei 5.000 Wartungseinträgen, verknüpft mit 200 Maschinen und 800 Ersatzteilen? Vergiss es.
Was du brauchst, ist eine lebendige Verbindung zwischen Claude und deiner Datenbank. Eine, die in Echtzeit funktioniert, in beide Richtungen, und die Claude versteht.
Die Architektur: Drei Schichten, alle lokal
Die Lösung besteht aus genau drei Komponenten. Alle laufen auf deinem Windows-Rechner. Nichts geht in eine Cloud (außer der Chat selbst – dazu später mehr).
┌─────────────────────────┐
│ Claude Desktop │ ← Hier stellst du Fragen
│ (Chat-Oberfläche) │
└────────────┬────────────┘
│ MCP-Protokoll (stdio)
┌────────────▼────────────┐
│ MCP-Server │ ← Python-Skript, das du schreibst
│ (deine Middleware) │
└────────────┬────────────┘
│ pyodbc / ODBC
┌────────────▼────────────┐
│ Access-Datenbank │ ← Deine bestehende .accdb
│ (bleibt unverändert) │
└─────────────────────────┘
Claude Desktop ist die Chat-Oberfläche von Anthropic. Kostenlos installierbar, braucht aber einen Claude-Account (ab Pro).
Der MCP-Server ist das Herzstück und dein eigentliches Entwicklungsprodukt. Ein Python-Skript, das „Tools“ bereitstellt – also Funktionen, die Claude aufrufen kann. Zum Beispiel: „Gib mir alle überfälligen Wartungen“ oder „Lege eine neue Störung an“.
Die Access-Datenbank bleibt, wie sie ist. Kein zusätzliches Feld, keine zusätzliche Tabelle. Der MCP-Server ist ein externer Leser (und optional Schreiber), der über den ganz normalen ODBC-Treiber zugreift – genau so, wie du es aus VBA mit DAO oder ADO kennst, nur eben von außen.
Was ist MCP – und warum sollte dich das interessieren?
MCP steht für Model Context Protocol. Es ist ein offenes Protokoll von Anthropic (den Machern von Claude), das definiert, wie eine KI mit externen Datenquellen kommuniziert.
Stell dir MCP als den USB-Standard für KI vor. So wie USB definiert, wie ein Drucker mit deinem Rechner spricht, definiert MCP, wie Claude mit deiner Datenbank spricht. Du baust einen „Treiber“ (den MCP-Server), und Claude weiß automatisch, wie er ihn benutzt.
Was MCP für dich konkret tut:
Tool-Registrierung: Du definierst Funktionen (z.B. get_kritische_wartungen), gibst ihnen eine Beschreibung in natürlicher Sprache und legst fest, welche Parameter sie akzeptieren. Claude liest diese Beschreibungen und entscheidet selbstständig, welches Tool zu einer Frage passt.
Automatisches Routing: Wenn ein Anwender fragt „Welche Wartungen sind überfällig?“, erkennt Claude, dass er das Tool get_ueberfaellige_wartungen aufrufen muss – ohne dass du If-Else-Logik schreiben musst.
Strukturierte Antworten: Dein Tool gibt JSON zurück. Claude macht daraus eine menschenlesbare Antwort. Du kümmmerst dich um die Daten, Claude kümmert sich um die Sprache.
Bidirektional: Du kannst Lese-Tools bauen (SELECT) und Schreib-Tools (INSERT, UPDATE) – Claude kann also nicht nur Auskunft geben, sondern auch Datensätze anlegen oder ändern.
Was du brauchst (Voraussetzungen)
Bevor du loslegst, check diese Liste:
Windows 10 oder 11 – MCP-Server mit pyodbc braucht Windows wegen des Access-ODBC-Treibers.
Microsoft Access ODBC-Treiber – Wenn Access auf deinem Rechner installiert ist, hast du den Treiber wahrscheinlich schon. Wichtig: Die Architektur (32-bit oder 64-bit) muss zu deinem Python passen. Hast du Office 32-bit installiert, brauchst du Python 32-bit – oder du installierst die „Microsoft Access Database Engine“ separat in 64-bit.
Python 3.11 oder neuer – Falls du noch kein Python hast: python.org, Download, installieren, „Add to PATH“ ankreuzen, fertig. Als VBA-Entwickler wirst du dich in Python schnell zurechtfinden – die Syntax ist sogar einfacher.
Claude Desktop – Kostenlos herunterzuladen auf claude.ai/download. Braucht einen Claude Pro-Account (ca. 20 USD/Monat).
Zwei Python-Pakete:
pip install mcp pyodbc
Das ist alles. Kein Docker, kein Node.js, kein Linux.
Das Minimalbeispiel: Schritt für Schritt
Jetzt wird’s konkret. Wir bauen einen MCP-Server, der eine Access-Datenbank mit Maschinen und Wartungen anbindet. Zwei Tools: eines zum Lesen kritischer Wartungen, eines zum Anlegen neuer Einträge.
Schritt 1: Access-Datenbank
Du brauchst eine .accdb mit zwei Tabellen. Wenn du eine bestehende DB hast, nimm die. Für dieses Beispiel reicht eine simple Testdatenbank:
Tabelle Maschinen:
| MaschineID (Autowert) | Name (Text) | Standort (Text) |
|---|---|---|
| 1 | Fräse CNC-500 | Halle A |
| 2 | Drehbank DL-200 | Halle A |
| 3 | Presse HP-800 | Halle C |
Tabelle Wartungen:
| WartungID (Autowert) | MaschineID (Zahl) | Datum (Datum) | Status (Text) | Notiz (Text) |
|---|---|---|---|---|
| 1 | 1 | 15.01.2025 | OK | Routinecheck |
| 2 | 1 | 20.03.2025 | kritisch | Spindelgeräusche |
| 3 | 3 | 10.04.2025 | kritisch | Druckabfall Hydraulik |
Erstell das in Access, speichere als wartung_demo.accdb. Fertig.
Schritt 2: Der MCP-Server (server.py)
Erstelle eine Datei server.py. Das ist dein kompletter MCP-Server:
import pyodbc
from datetime import date
from mcp.server.fastmcp import FastMCP
# --- Konfiguration ---
DB_PATH = r"C:\MeinPfad\wartung_demo.accdb"
CONN_STR = (
r"DRIVER={Microsoft Access Driver (*.mdb, *.accdb)};"
f"DBQ={DB_PATH};"
)
# --- MCP-Server erstellen ---
mcp = FastMCP(
"Wartung Access Demo",
instructions="""Du bist ein Assistent für Instandhaltung.
Du hast Zugriff auf eine Wartungsdatenbank mit Maschinen und Wartungseinträgen.
Antworte auf Deutsch. Wenn du Daten aus der Datenbank zeigst,
formatiere sie übersichtlich."""
)
# --- Hilfsfunktion: DB-Verbindung ---
def query(sql, params=None):
conn = pyodbc.connect(CONN_STR)
cursor = conn.cursor()
cursor.execute(sql, params or [])
columns = [desc[0] for desc in cursor.description]
rows = [dict(zip(columns, row)) for row in cursor.fetchall()]
conn.close()
return rows
def execute(sql, params=None):
conn = pyodbc.connect(CONN_STR)
cursor = conn.cursor()
cursor.execute(sql, params or [])
conn.commit()
conn.close()
# --- Tool 1: Kritische Wartungen lesen ---
@mcp.tool()
def get_kritische_wartungen() -> list[dict]:
"""Gibt alle Wartungen mit Status 'kritisch' zurück,
inklusive Maschinenname, Datum und Notiz.
Nutze dieses Tool wenn der Anwender nach kritischen,
dringenden oder problematischen Wartungen fragt."""
return query("""
SELECT m.Name AS Maschine,
w.Datum,
w.Notiz,
w.WartungID
FROM Wartungen w
INNER JOIN Maschinen m ON w.MaschineID = m.MaschineID
WHERE w.Status = 'kritisch'
ORDER BY w.Datum DESC
""")
# --- Tool 2: Neue Wartung anlegen ---
@mcp.tool()
def create_wartung(
maschine_id: int,
status: str,
notiz: str = "",
datum: str = ""
) -> str:
"""Legt eine neue Wartung in der Datenbank an.
Parameter:
- maschine_id: Die ID der Maschine (z.B. 1, 2, 3)
- status: Entweder 'OK' oder 'kritisch'
- notiz: Beschreibung der Wartung (optional)
- datum: Datum im Format YYYY-MM-DD (optional, Default: heute)
Nutze dieses Tool wenn der Anwender eine Wartung
erfassen, eintragen oder dokumentieren möchte."""
if status not in ("OK", "kritisch"):
return "Fehler: Status muss 'OK' oder 'kritisch' sein."
if not datum:
datum = date.today().isoformat()
execute(
"INSERT INTO Wartungen (MaschineID, Datum, Status, Notiz) VALUES (?, ?, ?, ?)",
[maschine_id, datum, status, notiz]
)
return f"Wartung angelegt: Maschine {maschine_id}, Status {status}, Datum {datum}"
# --- Server starten ---
if __name__ == "__main__":
mcp.run(transport="stdio")
Was hier passiert, Zeile für Zeile:
Der pyodbc.connect() baut eine ODBC-Verbindung zu deiner .accdb auf – genau das Prinzip, das du aus ADO in VBA kennst, nur in Python.
FastMCP ist die Komfort-Klasse aus dem offiziellen MCP Python SDK. Sie nimmt dir die ganze Protokoll-Logik ab. Du dekorierst eine Funktion mit @mcp.tool(), und sie wird automatisch als Tool registriert.
Entscheidend sind die Docstrings. Die Beschreibung in den dreifachen Anführungszeichen ist nicht für dich – sie ist für Claude. Claude liest diese Texte und entscheidet anhand davon, wann er welches Tool aufruft. Je klarer du beschreibst, was das Tool tut und wann es relevant ist, desto besser funktioniert die Zuordnung.
Die Funktion query() gibt eine Liste von Dictionaries zurück. Das MCP SDK serialisiert das automatisch zu JSON. Claude empfängt also strukturierte Daten und formt daraus eine Antwort in natürlicher Sprache.
Schritt 3: Claude Desktop konfigurieren
Öffne (oder erstelle) die Datei:
%APPDATA%\Claude\claude_desktop_config.json
Inhalt:
{
"mcpServers": {
"wartung-demo": {
"command": "python",
"args": ["C:\\MeinPfad\\server.py"]
}
}
}
Passe den Pfad an, speichere, starte Claude Desktop neu.
Schritt 4: Testen
Öffne Claude Desktop. Unten im Eingabefeld sollte jetzt ein Hammer-Symbol erscheinen – das zeigt an, dass dein MCP-Server erkannt wurde. Klick darauf und du siehst deine registrierten Tools.
Jetzt tippe:
Welche Wartungen sind kritisch?
Claude ruft dein Tool auf, bekommt die Daten aus Access und antwortet mit einer formatierten Übersicht. Echtdaten, live aus deiner .accdb.
Dann:
Lege eine neue Wartung an für Maschine 1, Status kritisch, Notiz: Kühlmittel läuft aus
Claude ruft create_wartung auf, der INSERT wird ausgeführt, die Datenbank hat einen neuen Datensatz. Öffne Access und sieh nach – er ist da.
Was hier gerade passiert ist
Nimm dir eine Sekunde Zeit und überleg, was du gebaut hast:
Du hast eine Access-Datenbank – unverändert, mit dem Schema, das du seit Jahren kennst. Und jetzt kann ein Anwender in natürlicher Sprache Fragen stellen und bekommt Antworten direkt aus den Daten. Ohne ein Formular zu öffnen. Ohne einen Bericht zu drucken. Ohne eine Abfrage zu kennen.
Das ist kein Gimmick. Überleg, wer in deinen Kundenbetrieben normalerweise nicht mit Access arbeitet: Geschäftsführer, Abteilungsleiter, Schichtführer. Die fragen den Access-Experten – also dich oder deinen Kunden – und warten auf einen Bericht. Mit MCP können sie direkt fragen. Die Daten können jetzt antworten.
Das Minimalbeispiel erweitern
Zwei Tools sind eine Demo. Für den echten Einsatz brauchst du mehr. Hier ein paar Ideen, was als nächstes kommen könnte:
Alle Maschinen auflisten – ein simpler SELECT * FROM Maschinen. Claude kann dann Fragen beantworten wie „Welche Maschinen stehen in Halle B?“
Wartungen filtern – ein Tool mit optionalen Parametern: Maschine, Status, Zeitraum. Damit Claude auf „Zeig mir alle Wartungen der Fräse seit Januar“ reagieren kann.
Statistiken – GROUP BY und COUNT in SQL, damit Claude sagen kann: „Die Presse hat die meisten Störungen – 7 im letzten Quartal.“
Verfügbarkeitsberechnung – MTBF und MTTR direkt aus den Störungsdaten berechnen. Das ist die Art von Auswertung, die in Access einen eigenen Bericht bräuchte.
Das Muster ist immer gleich: eine Python-Funktion mit @mcp.tool(), ein SQL-Query, ein Docstring. Wenn du SQL kannst – und als Access-Entwickler kannst du SQL – dann kannst du Tools bauen.
Typische Stolpersteine
ODBC-Treiber: 32-bit vs. 64-bit
Der häufigste Fehler. Access/Office ist oft 32-bit installiert, Python aber 64-bit. Die Verbindung schlägt dann fehl mit einer wenig hilfreichen Fehlermeldung. Lösung: Entweder Python 32-bit installieren oder die „Microsoft Access Database Engine“ in 64-bit separat nachinstallieren (geht auch parallel zu Office 32-bit, sofern du die /passive-Installation nutzt).
Datenbankpfad mit Leerzeichen
Der Pfad zur .accdb darf Leerzeichen enthalten – pyodbc kommt damit klar. Aber achte auf korrekte Escaping-Zeichen in Python: benutze r"..." (Raw-Strings) für Windows-Pfade.
Gleichzeitiger Zugriff
Wenn die .accdb gerade in Access geöffnet ist, kann der MCP-Server trotzdem lesen – Access unterstützt Concurrent Reads. Schreibzugriffe können aber kollidieren, wenn beide gleichzeitig denselben Datensatz ändern. Für den Einzelplatzbetrieb ist das in der Praxis selten ein Problem, aber im Mehrplatzbetrieb solltest du darüber nachdenken.
Claude „halluziniert“ trotzdem
Nein. Das ist ein verbreitetes Missverständnis. Wenn Claude ein MCP-Tool aufruft, bekommt er echte Daten aus deiner Datenbank. Er kann sich die Daten nicht ausdenken. Was er ausdenken kann, ist die Interpretation – z.B. „Das deutet auf ein systematisches Problem hin“ – aber die zugrundeliegenden Zahlen kommen aus deiner DB.
Datenschutz
Die Daten bleiben lokal auf deinem Rechner. Aber: Wenn Claude eine Antwort formuliert, sendet Claude Desktop den Kontext (also auch deine DB-Daten) an die Anthropic-API. Anthropic speichert diese Daten bei Pro- und Team-Accounts nicht für Trainingszwecke. Trotzdem: Wenn deine Kunden sensible Daten haben (Automotive, Medizin), sprich das Thema offen an. Es gibt Enterprise-Optionen mit Zero Data Retention.
Von der Demo zum Produkt
Das Minimalbeispiel oben ist ein Prototyp. Wenn du das als Dienstleistung für deine Kunden anbieten willst, brauchst du ein paar zusätzliche Dinge:
Ein Setup-Skript, das den ODBC-Treiber prüft, den DB-Pfad abfragt, die Claude-Desktop-Config schreibt und das Schema validiert. Dein Kunde soll nicht in JSON-Dateien rummachen müssen.
Einen Schema-Validator, der beim Start prüft, ob die erwarteten Tabellen und Felder existieren. Wenn jemand eine alte DB-Version hat, soll der Server sauber abbrechen statt kryptische SQL-Fehler zu werfen.
Durchdachte Tool-Beschreibungen auf Deutsch. Die Qualität der Beschreibungen entscheidet, ob Claude die richtige Abfrage trifft. Das ist kein einmaliger Aufwand – du wirst iterieren, basierend auf dem Feedback deiner Anwender.
Fehlerbehandlung. Was passiert, wenn die DB nicht erreichbar ist? Wenn ein INSERT gegen eine Validierungsregel verstößt? Jedes Tool sollte im Fehlerfall eine verständliche Meldung zurückgeben, die Claude dem Anwender weiterreichen kann.
Das Geschäftsmodell für dich als Access-Entwickler
Du hast Access-Kunden. Die haben funktionierende Datenbanken. Du kannst jetzt eine neue Leistung anbieten: „Ich mache Ihre Datenbank KI-fähig.“
Das ist kein Ersatz für deine bisherige Arbeit. Es ist eine Erweiterung. Die Access-Lösung bleibt das Rückgrat. Der KI-Connector ist ein Add-on – eine neue Zugangsebene zu denselben Daten.
Mögliche Angebotsstruktur:
- Ersteinrichtung (einmalig): Schema analysieren, MCP-Server entwickeln, beim Kunden installieren, Claude Desktop einrichten.
- Tool-Erweiterung (nach Bedarf): Weitere Tools für zusätzliche Tabellen oder Auswertungen.
- Support (laufend): Bei Fragen, Updates, neuen INSTA/Access-Versionen.
Du verkaufst nicht „KI“. Du verkaufst: Ihre Daten können jetzt antworten.
Was du als nächstes tun solltest
Jetzt: Bau das Minimalbeispiel nach. Nimm eine deiner eigenen Access-Datenbanken und verbinde sie. Stell Claude eine Frage und sieh, wie die Antwort aus deinen echten Daten kommt. Das ist der Moment, in dem es klick macht.
Dann: Überleg, welcher deiner Kunden am meisten davon profitieren würde. Wahrscheinlich einer mit vielen Daten und wenig Auswertungsmöglichkeiten. Zeig ihm die Demo.
Und dann: Bau es aus. Mehr Tools, bessere Beschreibungen, ein sauberes Setup. Du hast als Access-Entwickler alles, was du brauchst: Du kennst die Daten, du kennst SQL, du kennst die Geschäftsprozesse deiner Kunden. Python ist nur das Transportmittel.
Access ist nicht tot. Access hat gerade eine neue Schnittstelle bekommen.
Du willst deine Access-Lösung MCP-ready machen und brauchst Unterstützung bei Konzept oder Umsetzung? Kontakt aufnehmen
