Python API

Complete reference for the CortexaDB Python package.

CortexaDB

The main database class.

CortexaDB.open(path, **kwargs)

Opens or creates a database at the specified path.

Parameters:

Returns: CortexaDB

Example:

from cortexadb import CortexaDB
from cortexadb.providers.openai import OpenAIEmbedder

# With embedder
db = CortexaDB.open("agent.mem", embedder=OpenAIEmbedder())

# With manual dimension
db = CortexaDB.open("agent.mem", dimension=128, sync="batch")

# With HNSW indexing
db = CortexaDB.open("agent.mem", dimension=128, index_mode={
    "type": "hnsw", "m": 16, "ef_search": 50, "metric": "cos"
})

CortexaDB.replay(log_path, db_path, **kwargs)

Rebuilds a database from a replay log file.

Parameters:

Returns: CortexaDB

Example:

db = CortexaDB.replay("session.log", "restored.mem", strict=False)
report = db.last_replay_report

Memory Operations

.remember(text, embedding=None, metadata=None)

Stores a new memory entry. If an embedder is configured and no embedding is provided, the text is auto-embedded.

Parameters:

Returns: int - The assigned memory ID

Example:

mid = db.remember("User prefers dark mode")
mid = db.remember("text", metadata={"source": "onboarding"})
mid = db.remember("text", embedding=[0.1, 0.2, ...])

.ask(query, embedding=None, top_k=5, use_graph=False, recency_bias=False)

Performs a hybrid search across the database.

Parameters:

Returns: list[Hit]

Example:

hits = db.ask("What does the user prefer?")
hits = db.ask("query", top_k=10, use_graph=True, recency_bias=True)

for hit in hits:
    print(f"ID: {hit.id}, Score: {hit.score:.3f}")

.get_memory(mid)

Retrieves a full memory entry by ID.

Parameters:

Returns: Memory

Raises: CortexaDBNotFoundError if the memory doesn't exist.

Example:

mem = db.get_memory(42)
print(mem.id)          # 42
print(mem.content)     # b"User prefers dark mode"
print(mem.namespace)   # "default"
print(mem.metadata)    # {"source": "onboarding"}
print(mem.created_at)  # 1709654400
print(mem.importance)  # 0.0
print(mem.embedding)   # [0.1, 0.2, ...] or None

.delete_memory(mid)

Permanently deletes a memory and updates all indexes.

Parameters:

Raises: CortexaDBNotFoundError if the memory doesn't exist.

Example:

db.delete_memory(42)

Graph Operations

.connect(from_id, to_id, relation)

Creates a directed edge between two memories.

Parameters:

Example:

db.connect(1, 2, "relates_to")
db.connect(1, 3, "caused_by")

Both memories must be in the same namespace. Cross-namespace edges are forbidden.

.get_neighbors(mid)

Returns all outgoing edges from a memory.

Parameters:

Returns: list[Edge] where each Edge has to (int) and relation (str) fields.

Example:

neighbors = db.get_neighbors(1)
for edge in neighbors:
    print(f"→ {edge.to} ({edge.relation})")

Document Ingestion

.ingest(text, strategy="recursive", chunk_size=512, overlap=50, metadata=None, namespace=None)

Chunks text and stores each chunk as a memory.

Parameters:

Returns: list[int] - Memory IDs of stored chunks

.load(file_path, strategy="markdown", chunk_size=512, overlap=50, metadata=None, namespace=None)

Loads a file, chunks it, and stores each chunk.

Parameters:

Supported formats: .txt, .md, .json, .docx (requires cortexadb[docs]), .pdf (requires cortexadb[pdf])

Example:

db.load("README.md", strategy="markdown")
db.load("paper.pdf", strategy="recursive", chunk_size=1024)

.ingest_document(text, chunk_size=512, overlap=50, metadata=None, namespace=None)

Legacy method for chunking and storing text. Uses fixed chunking.

Namespace

.namespace(name, readonly=False)

Returns a scoped view of the database for a specific namespace.

Parameters:

Returns: Namespace

Example:

ns = db.namespace("agent_a")
mid = ns.remember("text")
hits = ns.ask("query")
ns.delete_memory(mid)
ns.ingest_document("long text")

Maintenance Operations

.compact()

Reclaims disk space by removing deleted entries from segment files.

.flush()

Forces all pending writes to be synced to disk.

.checkpoint()

Creates a binary snapshot of the current state and truncates the WAL. Also saves the HNSW index if using HNSW mode.

.stats()

Returns database statistics.

Returns: Stats

stats = db.stats()
print(stats.entries)              # Total memory count
print(stats.indexed_embeddings)   # Embeddings in vector index
print(stats.wal_length)           # WAL file size in bytes
print(stats.vector_dimension)     # Configured vector dimension
print(stats.storage_version)      # Storage format version

Replay Properties

.last_replay_report

Diagnostic report from the most recent replay() call.

Type: dict

.last_export_replay_report

Diagnostic report from the most recent export_replay() call.

Type: dict

Export

.export_replay(path)

Exports the current database state as a replay log.

Parameters:

Types

Hit

Query result from .ask().

Memory

Full memory entry from .get_memory().

Stats

Database statistics from .stats().

ChunkResult

Result from chunk().

Standalone Functions

chunk(text, strategy="recursive", chunk_size=512, overlap=50)

Chunks text without storing it.

Returns: list[ChunkResult]

from cortexadb import chunk

chunks = chunk("Long text...", strategy="recursive", chunk_size=512, overlap=50)

Exceptions