seekdb

Use pylibseekdb to start a local seekdb database, then execute SQL with PyMySQL. Requires Python 3.11 or newer.

python3 -m pip install -U pylibseekdb pymysql

Save the following as example.py. It gets the connection arguments from connection_options() and passes them to PyMySQL. The context managers close the cursor and SQL connection before releasing the runtime handle:

from contextlib import closing

import pylibseekdb
import pymysql

with closing(pylibseekdb.open("./seekdb.db")) as db:
    options = db.connection_options()
    with pymysql.connect(
        database="test",
        autocommit=True,
        cursorclass=pymysql.cursors.DictCursor,
        **options,
    ) as connection:
        with connection.cursor() as cursor:
            cursor.execute("SELECT 1 AS value")
            print(cursor.fetchall())

Run it; the result is [{'value': 1}]:

python3 example.py

Full usage guide · Supported platforms and requirements

For a higher-level Collection API with text embedding and hybrid search, see pyseekdb.

Use @oceanbase/seekdb-node to start a local seekdb database, then execute SQL with mysql2. Requires Node.js 22 or newer and supports both JavaScript and TypeScript.

npm install @oceanbase/seekdb-node mysql2

Keep npm optional dependencies enabled so npm installs the matching native runtime. The binding manages a separate local seekdb process; close SQL connections before releasing its runtime handle.

Save the following as example.mjs (ES modules; TypeScript declarations are also included):

import { seekdb } from "@oceanbase/seekdb-node";
import mysql from "mysql2/promise";

const db = await seekdb.open("./seekdb.db");
let connection;
try {
  const endpoint = db.connectionOptions();
  const location = endpoint.transport === "tcp"
    ? { host: endpoint.host, port: endpoint.port }
    : { socketPath: endpoint.transport === "unix_socket"
        ? endpoint.unixSocket : endpoint.namedPipe };
  connection = await mysql.createConnection({
    ...location,
    user: endpoint.user,
    password: "",
    database: "test",
  });
  const [rows] = await connection.query("SELECT 1 AS value");
  console.log(rows);
} finally {
  try {
    if (connection) await connection.end();
  } finally {
    db.close();
  }
}

Run it; the result is [ { value: 1 } ]:

node example.mjs

Full usage guide and supported platforms

For a higher-level JavaScript Collection API, see seekdb-js.

Use seekdb-go to start a local seekdb database, then execute SQL with go-sql-driver/mysql. This example requires Go 1.24 or newer, CGO_ENABLED=1, and a C compiler.

mkdir seekdb-go-example
cd seekdb-go-example
go mod init example.com/seekdb-demo

Save the following as main.go. It uses the endpoint returned by ConnectionOptions and closes the SQL connections before releasing the runtime handle:

package main

import (
	"database/sql"
	"fmt"
	"log"
	"net"

	"github.com/go-sql-driver/mysql"
	seekdb "github.com/oceanbase/seekdb-go"
)

func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

func run() error {
	db, err := seekdb.Open("./seekdb.db")
	if err != nil {
		return err
	}
	defer db.Close()

	endpoint, err := db.ConnectionOptions()
	if err != nil {
		return err
	}
	cfg := mysql.NewConfig()
	cfg.User, cfg.DBName = endpoint.User, "test"
	switch endpoint.Transport {
	case "unix_socket":
		cfg.Net, cfg.Addr = "unix", endpoint.UnixSocket
	case "tcp":
		cfg.Net, cfg.Addr = "tcp", net.JoinHostPort(endpoint.Host, fmt.Sprint(endpoint.Port))
	default:
		return fmt.Errorf("unsupported transport %q", endpoint.Transport)
	}
	connection, err := sql.Open("mysql", cfg.FormatDSN())
	if err != nil {
		return err
	}
	defer connection.Close()

	var value int
	if err := connection.QueryRow("SELECT 1 AS value").Scan(&value); err != nil {
		return err
	}
	fmt.Println(value)
	return nil
}

Run it; Go resolves the dependencies and downloads the native bundle for your current platform. The result is 1:

go run -mod=mod .

A regular go get for seekdb-go or go mod tidy may download bundles for all supported platforms.

Full usage guide · Supported platforms and requirements

One curl, a running database — no signup, no credit card.

curl -X POST https://d0.seekdb.ai/api/v1/instances

Free for 7 days. Learn more →

docker run -d \
  --name seekdb \
  -p 2881:2881 \
  -p 2886:2886 \
  -v ./data:/var/lib/oceanbase \
  oceanbase/seekdb:latest

Please refer to the document of this docker image for details.

# Linux (one-line install, may need sudo)
curl -fsSL https://obportal.s3.ap-southeast-1.amazonaws.com/download-center/opensource/seekdb/seekdb_install.sh | bash

# macOS (Homebrew)
brew tap oceanbase/seekdb
brew install seekdb

See deployment docs for DEB/RPM offline install and configuration details.

The canonical agent loop: write an observation, retrieve relevant context milliseconds later, repeat. seekdb’s async index pipeline keeps both sides fast under sustained concurrency.

import pyseekdb

client = pyseekdb.Client(path="./agent_state.db")
memory = client.get_or_create_collection(name="episodic")

for step in agent.run():
    # Persist the observation
    memory.upsert(ids=[step.id], documents=[step.observation])

    # Retrieve relevant context — milliseconds after the write,
    # served by the incremental HNSW (no waiting on a background rebuild)
    relevant = memory.query(query_texts=step.next_query, n_results=5)

    agent.act(relevant)

-- Table with vector column, full-text index, and HNSW vector index
CREATE TABLE articles (
  id        INT PRIMARY KEY,
  title     TEXT,
  content   TEXT,
  embedding VECTOR(384),
  FULLTEXT INDEX idx_fts (content) WITH PARSER ik,
  VECTOR   INDEX idx_vec (embedding) WITH (DISTANCE=l2, TYPE=hnsw, LIB=vsag)
) ORGANIZATION = HEAP;

-- Hybrid search: vector similarity + full-text match in one query
SELECT id, title,
       l2_distance(embedding, '[0.12, 0.34, ...]') AS dist
FROM articles
WHERE MATCH(content) AGAINST('quarterly report')
ORDER BY dist APPROXIMATE
LIMIT 10;

Python developers can access this via SQLAlchemy or any MySQL driver.

Agents need a state store that handles continuous memory writes, millisecond-later retrieval, branching for exploration, and rollback when things go wrong. seekdb is built for exactly this:

• Streaming-friendly storage — write a memory, query it in the next ms
• COW sandboxes — FORK DATABASE for safe experimentation, MERGE to accept, DROP to roll back
• Hybrid retrieval — vector + full-text + relational in one SQL
• MySQL protocol — works with LangChain, LlamaIndex, Dify out of the box

Personal assistants · Enterprise automation · Vertical agents · Agent platforms

seekdb’s hybrid retrieval + multi-model engine also fits classic AI workloads:

• 📖 RAG & Knowledge Retrieval — vector + full-text + scalar filters with multi-level access control. Enterprise QA, customer support, industry insights, personal knowledge bases.
• 🔍 Semantic Search — embedding-based search across text, images, and other modalities. Product search, text-to-image, image-to-product.
• 💻 AI-Assisted Coding — semantic code search, multi-project isolation, time-travel queries for IDE plugins and code agents. Local IDEs, web IDEs, design-to-web.
• ⬆️ Enterprise Application Intelligence — MySQL-compatible AI layer for legacy systems, with row/column hybrid storage. Document intelligence, business insights, finance systems.
• 📱 On-Device & Edge AI — embedded / micro-server modes for resource-constrained devices. In-vehicle systems, AI education, companion robots, healthcare devices.