Atlas 2.0 — Dauerhafter Speicher für Codierungsagenten

Atlas gibt Codierungsagenten ein Gedächtnis. Ihre KI kann Code schreiben. Atlas sorgt dafür, dass sie sich an das Warum erinnert.

Was ist Atlas?

Atlas ist eine dauerhafte, repository-bewusste Speicherinfrastruktur für autonome Codierungsagenten. Es verwendet CockroachDB als dauerhaftes Aufzeichnungssystem für sowohl strukturiertes als auch semantisches Gedächtnis und ermöglicht Agenten:

• Sitzungsübergreifendes Erinnern — Kontext überlebt Agentenneustarts

• Aus der Git-Historie lernen — automatisches Extrahieren von Erinnerungen aus Commits

• Semantische Suche — Vektor-kNN über AWS Bedrock Embeddings

• Arbeit übergeben — strukturierte Kontextübergabe zwischen Agenten

• Entscheidungen nachverfolgen — warum Entscheidungen getroffen wurden, welche Alternativen existierten

Related MCP server: agent-memory

Architektur

┌─────────────────────────────────────────────────────────┐
│  Claude Code / Codex / Cursor (MCP Client)             │
└────────────────┬────────────────────────────────────────┘
                 │ MCP Protocol
┌────────────────▼────────────────────────────────────────┐
│  Atlas MCP Server (10 tools)                           │
│  - atlas_start_session                                 │
│  - atlas_save_memory                                   │
│  - atlas_record_decision                               │
│  - atlas_scan_repository                               │
│  - atlas_extract_git_memories                          │
│  - atlas_search_memory                                 │
│  - atlas_end_session                                   │
└────────────────┬────────────────────────────────────────┘
                 │
┌────────────────▼────────────────────────────────────────┐
│  Atlas Memory Layer                                     │
│  - writer.ts  (session lifecycle, memory persistence)  │
│  - retrieval.ts (11 query functions)                   │
│  - embedder.ts (AWS Bedrock Titan v2, 1024d vectors)  │
└────────────────┬────────────────────────────────────────┘
                 │
┌────────────────▼────────────────────────────────────────┐
│  CockroachDB Cloud (Source of Truth)                   │
│  - Structured memory (Prisma models)                   │
│  - Semantic memory (VECTOR + kNN)                      │
└─────────────────────────────────────────────────────────┘

Funktionen

Kernspeichersystem

• Sitzungsverfolgung — jede Codierungssitzung hat eine Zeitleiste von Erinnerungen + Entscheidungen

• Erinnerungstypen — ARCHITECTURE, DECISION, BUG, TODO, WARNING, IMPORTANT_FILE, DEPENDENCY, SECURITY, CONTEXT

• Wichtigkeitsfilter — nur Erinnerungen mit Wichtigkeit ≥ 3 werden eingebettet (reduziert Kosten)

• Auflösungsverfolgung — TODOs und BUGs können als erledigt markiert werden, ohne gelöscht zu werden

Intelligente Extraktion

• Repository-Scanner — automatische Erkennung des Tech-Stacks aus package.json, requirements.txt, go.mod, Cargo.toml

• Git-Erinnerungsextraktion — analysiert Commit-Nachrichten und Dateiänderungen, um Erinnerungen zu generieren

• Architekturentdeckung — extrahiert Systemdesign aus README.md

• Wichtige Dateien — identifiziert kritische Dateien (Konfiguration, Schema, Manifeste)

Semantische Suche

• Vektor-kNN — unterstützt durch AWS Bedrock Titan Embeddings v2

• Multi-Repo-Suche — Suche über alle Repositories oder auf eines beschränken

• Artfilterung — nach Erinnerungstyp filtern

• Prüfprotokoll — jeder Abruf wird zur Beobachtbarkeit protokolliert

Agentenübergabe

• Strukturierte Übergaben — "Was ich getan habe / Was fehlgeschlagen ist / Was als Nächstes kommt"

• .atlas/-Projektionsdateien — portabler Fallback, wenn der MCP-Server nicht verbunden ist

• Dort weitermachen, wo Sie aufgehört haben — die UI zeigt Zusammenfassung der letzten Sitzung, offene Aufgaben, wichtige Entscheidungen

Einrichtung

1. Voraussetzungen

• Node.js 18+

• CockroachDB Cloud-Konto (kostenlose Stufe funktioniert)

• AWS-Konto mit Bedrock-Zugriff (Titan Embeddings v2)

2. Umgebungsvariablen

Erstellen Sie .env:

# CockroachDB connection string
DATABASE_URL="postgresql://user:password@cluster.cockroachlabs.cloud:26257/defaultdb?sslmode=require"

# AWS Bedrock (for embeddings)
AWS_REGION="us-east-1"
AWS_ACCESS_KEY_ID="your-key"
AWS_SECRET_ACCESS_KEY="your-secret"

3. Datenbankeinrichtung

# Install dependencies
npm install

# Apply schema to CockroachDB
npx prisma db push

# Generate Prisma Client
npx prisma generate

4. MCP-Server-Einrichtung

Fügen Sie Ihren Claude Code-Einstellungen hinzu (~/.config/claude-code/settings.json):

{
  "mcpServers": {
    "atlas": {
      "command": "node",
      "args": ["/path/to/atlas-2/mcp-server/dist/index.js"],
      "env": {
        "DATABASE_URL": "postgresql://...",
        "AWS_REGION": "us-east-1",
        "AWS_ACCESS_KEY_ID": "...",
        "AWS_SECRET_ACCESS_KEY": "..."
      }
    }
  }
}

5. Auto-Fire-Hook (optional)

Installieren Sie den SessionStart-Hook, damit der Atlas-Kontext automatisch jedes Mal eingefügt wird, wenn Sie eine Claude Code-Sitzung starten — kein manueller atlas_start_session-Aufruf erforderlich:

bash scripts/install-autofire.sh

Dies schreibt einen SessionStart-Hook in ~/.config/claude-code/settings.json. Wenn Sie Claude Code in einem Repository öffnen, das .atlas/-Dateien oder eine ATLAS.md enthält, wird der Kontext zu Sitzungsbeginn ausgegeben. Der Hook bleibt für Repositories stumm, die Atlas noch nicht gesehen hat.

6. Starten der Benutzeroberfläche

npm run dev

Besuchen Sie http://localhost:3000, um das Atlas-Dashboard zu sehen.

Verwendung

Von Claude Code aus

# Start a session (auto-fired if you installed the hook, otherwise call manually)
atlas_start_session(repoPath="/home/user/my-project", repoName="my-project", agentId="claude-code")

# Scan repository for tech stack and architecture
atlas_scan_repository(repoPath="/home/user/my-project", repoId="...")

# Extract memories from git history
atlas_extract_git_memories(sessionId="...", repoId="...", repoPath="/home/user/my-project")

# Save a memory
atlas_save_memory(sessionId="...", repoId="...", kind="ARCHITECTURE", content="Uses Next.js 14 with App Router", importance=4)

# Record a decision
atlas_record_decision(sessionId="...", repoId="...", title="Use Prisma over Drizzle", rationale="Team familiarity", alternatives=["Drizzle", "TypeORM"])

# Search memories
atlas_search_memory(query="how does authentication work?", repoPath="/home/user/my-project")

# Generate ATLAS.md (portable session-start primer, no MCP needed)
atlas_generate_atlas_md(repoPath="/home/user/my-project")

# Reconstruct project timeline
atlas_reconstruct_timeline(repoPath="/home/user/my-project", since="2026-01-01")

# End session
atlas_end_session(sessionId="...", summary="Added user authentication", repoPath="/home/user/my-project")

Von OpenAI Codex / VS Code Agent Mode (Agentenübergreifend)

Atlas spricht standardmäßiges MCP — jeder Agent, der das Model Context Protocol unterstützt, kann es verwenden. Fügen Sie für Codex in VS Code Atlas zu Ihrer .vscode/mcp.json hinzu:

{
  "servers": {
    "atlas": {
      "type": "stdio",
      "command": "node",
      "args": ["/path/to/atlas-2/mcp-server/dist/index.js"],
      "env": {
        "DATABASE_URL": "postgresql://...",
        "AWS_REGION": "us-east-1",
        "AWS_ACCESS_KEY_ID": "...",
        "AWS_SECRET_ACCESS_KEY": "..."
      }
    }
  }
}

Sowohl Claude Code als auch Codex schreiben in denselben CockroachDB-Cluster, sodass Erinnerungen, die in einem Agenten erstellt wurden, sofort dem anderen zur Verfügung stehen. Das Feld agentId in jedem Sitzungs- und Erinnerungsdatensatz verfolgt, welcher Agent es geschrieben hat.

Von der Benutzeroberfläche aus

• Arbeitsbereich (/) — Alle Repositories mit Sitzungsanzahl, offenen Aufgaben, letztem Agenten

• Repository (/repo/[id]) — Widget "Dort weitermachen, wo Sie aufgehört haben", letzte Sitzungen, offene Aufgaben, wichtige Entscheidungen

• Sitzung (/session/[id]) — Sitzungszeitleiste mit Erinnerungen + Entscheidungen chronologisch

• Suche (/search) — Semantische Erinnerungssuche über alle Repositories

API-Routen

• GET /api/repositories — Alle Repositories auflisten

• GET /api/repositories/[id] — Repository nach ID mit Kontext abrufen

• POST /api/sessions — Neue Sitzung starten

• GET /api/sessions/[id] — Sitzungsdetails abrufen

• POST /api/sessions/[id]/handoff — Übergabedokument generieren

• GET /api/memories/search?q=query — Semantische Suche

• GET /api/memories/stats — Speicherstatistiken

Bereitstellung

Vercel (Benutzeroberfläche)

# Install Vercel CLI
npm i -g vercel

# Deploy
vercel --prod

# Set environment variables in Vercel dashboard

MCP-Server

Der MCP-Server läuft lokal auf Ihrem Rechner. Jeder Entwickler muss ihn in seinen Claude Code-Einstellungen konfigurieren.

Für Team-Bereitstellungen erwägen Sie:

• Den MCP-Server auf einem gemeinsamen Entwicklungsserver ausführen

• SSH-Tunneling verwenden, um Claude Code mit einem entfernten MCP-Server zu verbinden

• Als Container mit gemeinsamer CockroachDB-Verbindung bereitstellen

Technologie-Stack

• Frontend — Next.js 14, React, TypeScript, Tailwind CSS

• Backend — Next.js API routes, Prisma ORM

• Datenbank — CockroachDB Cloud (PostgreSQL-kompatibel, Vektorunterstützung)

• Embeddings — AWS Bedrock Titan Embeddings v2 (1024d)

• MCP — Model Context Protocol (Claude Code integration)

• Bereitstellung — Vercel (UI), lokal/SSH (MCP-Server)

Warum CockroachDB?

• Vektorindizierung — nativer VECTOR-Typ mit Kosinus-Ähnlichkeitssuche

• Verteiltes SQL — horizontale Skalierbarkeit ohne Sharding-Komplexität

• Prisma-Unterstützung — typsichere Abfragen mit automatisch generiertem Client

• Kostenlose Stufe — 5 GB Speicher, perfekt für persönliche Projekte

Warum Atlas 2.0?

Atlas 1.0 war ein Blockchain-Wallet-Tracer — interessantes Produkt, aber tangential zum "agentischen Gedächtnis".

Atlas 2.0 IST ein agentisches Gedächtnissystem:

• ✅ Strukturiertes Gedächtnis (CockroachDB-Modelle: Sitzungen, Erinnerungen, Entscheidungen)

• ✅ Semantisches Gedächtnis (VECTOR + kNN-Suche über AWS Bedrock Embeddings)

• ✅ Dauerhaftes Gedächtnis (überlebt Sitzungen, reist mit Repository über .atlas/-Dateien)

• ✅ Multi-Agent (MCP für Claude/Codex + SDK für benutzerdefinierte Agenten)

• ✅ Repository-bewusst (Gedächtnis ist auf Projekte beschränkt, nicht nur auf Benutzerkonten)

Lizenz

MIT