Anleitung zum Onboarding des Akasha-Agenten

Vollständige Anleitung, um einen neuen Agenten mit Akasha zu verbinden.

Schritt 1: Holen Sie sich Ihre Anmeldeinformationen

Option A: API-Schlüssel (empfohlen für Agenten)

Bitten Sie einen Administrator, einen Schlüssel über das Dashboard oder die API zu erstellen:

curl -sk -X POST "$AKASHA_URL/api/v1/admin/keys" \
  -H "Authorization: Bearer $ADMIN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-new-agent",
    "namespaces": ["memory/working/my-new-agent/**", "memory/semantic/**", "memory/episodic/**"],
    "role": "agent"
  }'

Speichern Sie den zurückgegebenen key – er wird nur einmal angezeigt.

Option B: JWT-Token (Benutzersitzungen)

TOKEN=$(curl -sk -X POST "$AKASHA_URL/api/v1/auth/login" \
  -H "Content-Type: application/json" \
  -d '{"username":"my-user","password":"my-password"}' \
  | python3 -c "import json,sys; print(json.load(sys.stdin)['token'])")

Schritt 2: Wählen Sie Ihr SDK

Python (gRPC – empfohlen für Leistung)

pip install akasha-client

from akasha import AkashaClient

with AkashaClient("localhost:50051") as client:
    # Schreiben
    client.put("memory/working/my-agent/status", {"state": "ready"})
    
    # Lesen
    record = client.get("memory/working/my-agent/status")
    print(record.value)  # {"state": "ready"}
    
    # Abfrage
    results = client.query("memory/working/**")

Python (HTTP – einfacher, keine Proto-Kompilierung)

from akasha import AkashaHttpClient

client = AkashaHttpClient(
    "https://localhost:7777",
    verify_ssl=False  # Für selbstsignierte TLS-Zertifikate
)
client.login("my-user", "my-password")
# Oder API-Schlüssel verwenden:
# client = AkashaHttpClient("https://...", api_key="ak_my-agent_xxx")

client.put("memory/working/my-agent/status", {"state": "ready"})

Node.js

const { AkashaClient } = require('@akasha/client');

const client = new AkashaClient({
  address: 'localhost:50051',
  // oder für HTTP:
  // url: 'https://localhost:7777',
  // token: 'ak_my-agent_xxx'
});

await client.put('memory/working/my-agent/status', { state: 'ready' });
const record = await client.get('memory/working/my-agent/status');

Raw HTTP (jede Sprache)

# Setzen Sie diese in der Umgebung Ihres Agenten
export AKASHA_URL="https://localhost:7777"
export AKASHA_TOKEN="ak_my-agent_xxxxxxxxxxxx"

# Schreiben
curl -sk -X POST "$AKASHA_URL/api/v1/records/memory/working/my-agent/status" \
  -H "Authorization: Bearer $AKASHA_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"value": {"state": "ready"}}'

# Lesen
curl -sk "$AKASHA_URL/api/v1/records/memory/working/my-agent/status" \
  -H "Authorization: Bearer $AKASHA_TOKEN"

Schritt 3: Definieren Sie Ihre Namespace-Strategie

Wählen Sie eine Pfadstruktur basierend auf der Rolle Ihres Agenten:

Forschungs-Agent

memory/working/<agent-id>/task          ← Aktueller Aufgabenkontext
memory/episodic/research/<finding-id>   ← Rohe Erkenntnisse
memory/semantic/research/<insight>      ← Bestätigtes Wissen

Code-Agent

memory/working/<agent-id>/context       ← Aktueller Code-Kontext
memory/procedural/coding/<pattern>      ← Wiederverwendbare Code-Muster
memory/semantic/architecture/<decision> ← Architekturentscheidungen

Monitoring-Agent

memory/working/<agent-id>/alerts        ← Aktive Alarme
memory/episodic/incidents/<incident-id> ← Vorfall-Chronologie
memory/semantic/runbooks/<procedure>    ← Bewährte Abhilfemaßnahmen

Multi-Agenten-Team

shared/                                 ← Teamweiter gemeinsamer Zustand
  ├── config/<setting>                  ← Gemeinsame Konfiguration
  ├── tasks/<task-id>                   ← Aufgabenverteilung
  └── results/<task-id>                 ← Aufgabenergebnisse

memory/working/<agent-id>/              ← Privater Notizblock jedes Agenten

Schritt 4: Fügen Sie Akasha zu Ihrem System-Prompt hinzu

Fügen Sie diesen Block zum System-Prompt Ihres Agenten hinzu (passen Sie ihn an Ihre Domain an):

## Gemeinsamer Speicher (Akasha)

Sie sind mit einer gemeinsamen Wissensdatenbank verbunden. Nutzen Sie sie zum Erinnern und Teilen.

### Schreiben: POST /api/v1/records/<pfad>
  Body: {"value": <json>, "ttl_secs": <optional>}

### Lesen: GET /api/v1/records/<pfad>

### Suchen: GET /api/v1/query?pattern=<glob-muster>

### Signal: POST /api/v1/pheromones/<pfad>
  Body: {"signal_type":"entdeckung","message":"...","intensity":0.8}

Auth-Header: Authorization: Bearer <ihr-token>
Basis-URL: <ihre-akasha-url>

Verwenden Sie den Arbeitsspeicher (ttl_secs) für temporäre Zustände.
Verwenden Sie den semantischen Speicher für bestätigtes Wissen.
Überprüfen Sie vor Beginn neuer Arbeiten die Signale.

Schritt 5: Verbindung überprüfen

# Gesundheitscheck (keine Authentifizierung)
curl -sk $AKASHA_URL/api/v1/health

# Schreibtest
curl -sk -X POST "$AKASHA_URL/api/v1/records/test/hello" \
  -H "Authorization: Bearer $AKASHA_TOKEN" \
  -d '{"value": {"message": "Agent verbunden!"}}'

# Lesetest
curl -sk "$AKASHA_URL/api/v1/records/test/hello" \
  -H "Authorization: Bearer $AKASHA_TOKEN"

# Bereinigen
curl -sk -X DELETE "$AKASHA_URL/api/v1/records/test/hello" \
  -H "Authorization: Bearer $AKASHA_TOKEN"

Checkliste

API-Schlüssel oder JWT-Token erhalten
SDK installiert (Python/Node/HTTP)
Namespace-Strategie definiert
System-Prompt mit Akasha-Anweisungen aktualisiert
Verbindung überprüft (Gesundheitscheck → Schreiben → Lesen → Löschen)
Arbeitsspeicher verwendet TTL zum automatischen Ablauf

ocuil/akasha-public

Was ist akasha-public?

In Ihrer bevorzugten KI fragen

Dokumentation