python3 -m pip install -U pylibseekdb pymysql

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())

python3 example.py

npm install @oceanbase/seekdb-node mysql2

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();
  }
}

node example.mjs

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

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
}

go run -mod=mod .

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

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

# 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

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;