Docs

Integrations

Agent Brain lässt sich in jede Sprache und jedes Framework integrieren. Alle Beispiele sind copy-paste-ready.

Python

Mit der requests Library.

agent_brain.pypython

import requests

BASE_URL = "https://api.agentbrain.ch"
API_KEY = "dein_api_key"
WORKSPACE_ID = "deine-workspace-id"

headers = {
    "Content-Type": "application/json",
    "X-API-Key": API_KEY,
}


def store_memory(content: str, source_trust: float = 0.8, agent_id: str = None):
    """Speichert eine Erinnerung im Agent Brain."""
    response = requests.post(
        f"{BASE_URL}/memory/store",
        headers=headers,
        json={
            "workspace_id": WORKSPACE_ID,
            "content": content,
            "source_trust": source_trust,
            "agent_id": agent_id,
            "memory_type": "episodic",
        },
    )
    return response.json()


def recall_memory(query: str, limit: int = 10, agent_id: str = None):
    """Sucht im Gedächtnis nach relevanten Erinnerungen."""
    response = requests.post(
        f"{BASE_URL}/memory/recall",
        headers=headers,
        json={
            "workspace_id": WORKSPACE_ID,
            "query": query,
            "limit": limit,
            "agent_id": agent_id,
        },
    )
    return response.json()


def get_predictions():
    """Holt proaktive Alerts."""
    response = requests.get(
        f"{BASE_URL}/predict/{WORKSPACE_ID}",
        headers=headers,
    )
    return response.json()


# Beispiel
store_memory("Kunde Müller hat wegen der Heizung angerufen.", source_trust=0.8)
results = recall_memory("Was wissen wir über Müller?")
print(results["memories"])

TypeScript / Node.js

Mit nativem fetch.

agent-brain.tstypescript

const BASE_URL = "https://api.agentbrain.ch";
const API_KEY = "dein_api_key";
const WORKSPACE_ID = "deine-workspace-id";

const headers = {
  "Content-Type": "application/json",
  "X-API-Key": API_KEY,
};

export async function storeMemory(
  content: string,
  sourceTrust = 0.8,
  agentId: string | null = null
) {
  const res = await fetch(`${BASE_URL}/memory/store`, {
    method: "POST",
    headers,
    body: JSON.stringify({
      workspace_id: WORKSPACE_ID,
      content,
      source_trust: sourceTrust,
      agent_id: agentId,
      memory_type: "episodic",
    }),
  });
  return res.json();
}

export async function recallMemory(
  query: string,
  limit = 10,
  agentId: string | null = null
) {
  const res = await fetch(`${BASE_URL}/memory/recall`, {
    method: "POST",
    headers,
    body: JSON.stringify({
      workspace_id: WORKSPACE_ID,
      query,
      limit,
      agent_id: agentId,
    }),
  });
  return res.json();
}

export async function getPredictions() {
  const res = await fetch(`${BASE_URL}/predict/${WORKSPACE_ID}`, {
    headers,
  });
  return res.json();
}

// Beispiel
const result = await storeMemory("Meeting mit dem Team war produktiv.", 0.9);
console.log(result.memory_id, result.weight);

Claude Code (CLAUDE.md)

Füge diesen Block in die CLAUDE.md deines Projekts ein. Der Agent nutzt automatisch curl um zu speichern und zu erinnern.

CLAUDE.mdmarkdown

## Gedächtnis (Agent Brain)

Du hast ein permanentes Gedächtnis. Nutze es IMMER.

API: https://api.agentbrain.ch
Workspace: DEINE_WORKSPACE_ID
API-Key: DEIN_API_KEY

### SPEICHERN — nach jedem wichtigen Event:
```bash
curl -X POST https://api.agentbrain.ch/memory/store \
  -H "Content-Type: application/json" \
  -H "X-API-Key: DEIN_API_KEY" \
  -d '{"workspace_id": "DEINE_WORKSPACE_ID", "content": "WAS PASSIERT IST", "source_trust": 0.8}'
```

### ERINNERN — vor jeder Entscheidung:
```bash
curl -X POST https://api.agentbrain.ch/memory/recall \
  -H "Content-Type: application/json" \
  -H "X-API-Key: DEIN_API_KEY" \
  -d '{"workspace_id": "DEINE_WORKSPACE_ID", "query": "WONACH DU SUCHST"}'
```

### ALERTS — regelmässig prüfen:
```bash
curl https://api.agentbrain.ch/predict/DEINE_WORKSPACE_ID \
  -H "X-API-Key: DEIN_API_KEY"
```

### Regeln:
- Speichere JEDES wichtige Gespräch, jede Entscheidung, jeden Kontakt
- Frage IMMER das Gedächtnis bevor du eine Entscheidung triffst
- source_trust: 0.9 = offiziell, 0.5 = unbestätigt, 0.3 = Gerücht

CrewAI

Custom Memory Backend für CrewAI Agents.

brain_memory.pypython

import requests
from crewai.memory import Memory


class AgentBrainMemory(Memory):
    """Agent Brain als Memory-Backend für CrewAI."""

    def __init__(self, workspace_id: str, api_key: str, agent_id: str = None):
        self.base_url = "https://api.agentbrain.ch"
        self.workspace_id = workspace_id
        self.agent_id = agent_id
        self.headers = {
            "Content-Type": "application/json",
            "X-API-Key": api_key,
        }

    def save(self, content: str, source_trust: float = 0.8):
        response = requests.post(
            f"{self.base_url}/memory/store",
            headers=self.headers,
            json={
                "workspace_id": self.workspace_id,
                "content": content,
                "source_trust": source_trust,
                "agent_id": self.agent_id,
                "memory_type": "episodic",
            },
        )
        return response.json()

    def search(self, query: str, limit: int = 10):
        response = requests.post(
            f"{self.base_url}/memory/recall",
            headers=self.headers,
            json={
                "workspace_id": self.workspace_id,
                "query": query,
                "limit": limit,
                "agent_id": self.agent_id,
            },
        )
        data = response.json()
        return [m["content"] for m in data.get("memories", [])]

    def reset(self):
        pass  # Agent Brain memories persist by design


# Verwendung
memory = AgentBrainMemory(
    workspace_id="deine-workspace-id",
    api_key="dein_api_key",
    agent_id="optional-agent-id",
)

memory.save("Neuer Lead: Firma ABC, Kontakt: Max Muster")
results = memory.search("Was wissen wir über Firma ABC?")

LangChain

Memory Wrapper für LangChain Chains.

brain_langchain.pypython

import requests
from langchain.memory import BaseMemory
from typing import Dict, List, Any


class AgentBrainLangChainMemory(BaseMemory):
    """Agent Brain Memory für LangChain."""

    base_url: str = "https://api.agentbrain.ch"
    workspace_id: str
    api_key: str
    agent_id: str = None
    memory_key: str = "history"

    @property
    def memory_variables(self) -> List[str]:
        return [self.memory_key]

    def _get_headers(self) -> Dict:
        return {
            "Content-Type": "application/json",
            "X-API-Key": self.api_key,
        }

    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]:
        query = inputs.get("input", inputs.get("question", ""))
        if not query:
            return {self.memory_key: ""}

        response = requests.post(
            f"{self.base_url}/memory/recall",
            headers=self._get_headers(),
            json={
                "workspace_id": self.workspace_id,
                "query": query,
                "limit": 5,
                "agent_id": self.agent_id,
            },
        )
        data = response.json()
        memories = data.get("memories", [])
        context = "\n".join([m["content"] for m in memories])
        return {self.memory_key: context}

    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
        content = f"Input: {inputs.get('input', '')}\nOutput: {outputs.get('output', '')}"
        requests.post(
            f"{self.base_url}/memory/store",
            headers=self._get_headers(),
            json={
                "workspace_id": self.workspace_id,
                "content": content,
                "source_trust": 0.8,
                "agent_id": self.agent_id,
            },
        )

    def clear(self) -> None:
        pass  # Agent Brain memories persist by design


# Verwendung
memory = AgentBrainLangChainMemory(
    workspace_id="deine-workspace-id",
    api_key="dein_api_key",
)

n8n

HTTP Request Node Konfiguration für n8n Workflows.

n8n — Memory speichern (HTTP Request Node)json

{
  "method": "POST",
  "url": "https://api.agentbrain.ch/memory/store",
  "authentication": "genericCredentialType",
  "genericAuthType": "httpHeaderAuth",
  "sendHeaders": true,
  "headerParameters": {
    "parameters": [
      {
        "name": "X-API-Key",
        "value": "dein_api_key"
      }
    ]
  },
  "sendBody": true,
  "bodyParameters": {
    "parameters": [
      {
        "name": "workspace_id",
        "value": "deine-workspace-id"
      },
      {
        "name": "content",
        "value": "={{ $json.message }}"
      },
      {
        "name": "source_trust",
        "value": "0.8"
      }
    ]
  }
}

n8n — Memory abrufen (HTTP Request Node)json

{
  "method": "POST",
  "url": "https://api.agentbrain.ch/memory/recall",
  "authentication": "genericCredentialType",
  "genericAuthType": "httpHeaderAuth",
  "sendHeaders": true,
  "headerParameters": {
    "parameters": [
      {
        "name": "X-API-Key",
        "value": "dein_api_key"
      }
    ]
  },
  "sendBody": true,
  "bodyParameters": {
    "parameters": [
      {
        "name": "workspace_id",
        "value": "deine-workspace-id"
      },
      {
        "name": "query",
        "value": "={{ $json.query }}"
      },
      {
        "name": "limit",
        "value": "10"
      }
    ]
  }
}