Open Source Python SDK

Les agents IA oublient tout.
APIBASE leur donne une mémoire
lisible par les humains. AI agents forget everything.
APIBASE gives them memory
that humans can read.

Une mémoire persistante, structurée et vérifiable pour agents IA — appuyée par APIBASE, visible dans un navigateur.

Persistent, structured, auditable memory for AI agents — backed by APIBASE, visible in a browser.

from apibase import ApibaseClient, Memory
 
client = ApibaseClient("https://apibase.work", token)
mem   = Memory(client, table_id=30)
 
mem.remember("username", "Pierre")
mem.recall("username")  # → "Pierre"
mem.forget("username")
mem.search("Pierre")   # → matching records

Le problème avec la mémoire des agents IA aujourd’huiThe problem with AI agent memory today

À chaque session, votre agent repart de zéro. Les contournements sont pénibles — et aucun ne vous permet de voir clairement ce que l’agent croit savoir.

Every session, your agent starts from zero. The workarounds are painful — and none of them let you see what the agent actually knows.

Vector storesVector stores

Des embeddings illisibles pour un humain. Quand l’agent développe une fausse croyance, vous ne pouvez pas la corriger parce que vous ne pouvez pas la voir.

Embeddings that no human can read. When the agent builds a wrong belief, you can't fix it because you can't see it.

Fichiers JSONJSON files

Plat, peu structuré, difficile à interroger, sans historique. Correct pour un jouet, pénible à l’échelle.

Flat, no structure, no querying, no history. Fine for toy projects, painful at scale.

RienNothing

La solution la plus courante. Chaque session est une page blanche. L’agent n’apprend jamais.

The most common solution. Every session is a blank slate. The agent never learns.

APIBASE

Chaque mémoire est une ligne dans une vraie table. Un humain peut l’ouvrir, la lire, la corriger et la comprendre immédiatement.

Every memory is a row in a real table. A human can open it, read it, correct it, and understand it instantly.

L’agent et l’humain travaillent sur les mêmes données. C’est l’architecture — pas un module ajouté après coup. The agent and the human work on the same data. That's the architecture — not an add-on.

Pourquoi les agents IA aiment l’adressage TLCWhy AI agents love TLC addressing

APIBASE utilise une adresse déterministe pour chaque donnée : T{table} / L{ligne} / C{colonne}. Pas d’ambiguïté. Pas d’hallucination. Un LLM peut construire une requête valide sans deviner.

APIBASE uses a deterministic address for every piece of data: T{table} / L{line} / C{column}. No ambiguity. No hallucination. An LLM can construct a valid query without guessing.

# Every cell in your base has an exact address
T30/L1/C2          # memorys, line 1, column "memory"
T30/L              # all records in memorys
T30/L/C2/O1?V=x    # records where memory = x

L’espace d’adressage est entièrement énumérable et cohérent. C’est pour cela que les agents peuvent le parcourir naturellement — et que le modèle tient là où d’autres APIs forcent à deviner.

The address space is fully enumerable and self-consistent. This is why agents navigate it naturally — and why it works where other APIs fail.

HIVE — une flotte d’agents avec mémoire partagéeHIVE — a fleet of agents with shared memory

Un agent patron possède la base maître. Les agents travailleurs se connectent avec une clé partagée et écrivent directement leurs résultats. Le patron lit tout. L’humain voit tout.

A boss agent owns the master base. Worker agents connect via a shared key and write their findings directly. The boss reads everything. The human sees everything.

Boss agent (full token)
    └── owns the master base
    └── controls who can read, write, edit
 
Worker "research" (hive token — read + add)
    └── writes findings into boss memory
    └── cannot edit or delete what boss wrote
 
Worker "analyst" (hive token — read only)
    └── reads directives from boss
    └── cannot write
from apibase import ApibaseClient, HiveClient, Memory

# Boss reads and writes its own base
boss = ApibaseClient("https://apibase.work", full_token)
mem  = Memory(boss, table_id=30, agent_col="username", agent="boss")

# Worker writes into boss base via HIVE
worker = HiveClient("https://apibase.work", hive_token)
mem_w  = Memory(worker, table_id=30, basekey="claude", agent="research")

mem_w.remember("finding01", "Revenue spike detected on 2026-04-15")
mem.search("spike")  # boss finds it immediately

Chaque écriture est visible en temps réel dans l’interface APIBASE. Vous savez quel agent a écrit quoi, quand et pourquoi.

Every write is visible in real time through the APIBASE interface. You know which agent wrote what, when, and why.

Démarrage rapideQuick start

  1. Créer un compteCreate an account Inscrivez-vous sur apibase.work. Gratuit pour commencer. Sign up at apibase.work. Free to start.
  2. Créer une table memorysCreate a memorys table Ajoutez 4 colonnes dans cet ordre : id_memory · memory · username · value Add 4 columns in order: id_memory · memory · username · value
  3. Générer un tokenGenerate a token Scope : full. C’est tout — pas besoin de noter l’ID de table. Scope: full. That's all — no need to note any table ID.
  4. Installer et exécuterInstall and run pip install requests, puis clonez apibase-py. pip install requests then clone apibase-py. 
from apibase import ApibaseClient, Memory

client = ApibaseClient("https://apibase.work", "your-token")
mem    = Memory(client, table_id=30, agent_col="username", agent="myagent")

mem.remember("goal", "Summarize the quarterly report")
print(mem.recall("goal"))   # → "Summarize the quarterly report"
print(mem.all())            # → all memories for this agent

table_id=30 est fixe — memorys est enregistrée globalement comme GID.30 sur apibase.work. Chaque utilisateur qui crée cette table obtient automatiquement le même ID.

table_id=30 is fixed — memorys is globally registered as GID.30 on apibase.work. Every user who creates this table gets the same ID automatically.

Référence APIAPI reference

Méthodes MemoryMemory methods

MéthodeMethod DescriptionDescription
remember(key, value)Stocke ou met à jour une mémoireStore or update a memory
recall(key)Récupère une valeur par cléRetrieve a value by key
forget(key)Supprime une mémoireDelete a memory
search(text)Recherche dans les clés et les valeursSearch across keys and values
all()Toutes les mémoires, filtrées par agent si configuréAll memories (filtered by agent if set)

Workflow HIVEHIVE workflow

MéthodeMethod DescriptionDescription
request(basekey, table_id)Demande l’accès à une tableRequest access to a table
approve(basekey, id_hive)Approuve une demande en attenteApprove a pending request
publish(basekey, id_hive)Pousse un snapshot de données vers le demandeurPush a data snapshot to the requester

Conventions de nommageNaming conventions

APIBASE impose un nommage strict. Les clés de mémoire doivent suivre les mêmes règles — pas de soulignés, réservés à id_x et x_id. Utilisez username, pas user_name; utilisez la notation par point pour les significations composées : created.at.

APIBASE enforces strict naming. Memory keys must follow the same rules — no underscores (reserved for id_x and x_id). Use username not user_name, dot notation for composed meaning: created.at.