DEV Community: seekdb

We’re All Obsessed With Prompt Engineering. But Are We Asking the Wrong Question?

Echo.lee — Fri, 20 Mar 2026 06:14:47 +0000

We live in an era where the entire world is frantically learning prompt techniques.
Yet almost no one stops to ask: Is this even the right way?

As a five-year follower of Naval Ravikant, his latest conversation with his long-time friend Nivi pushed me to rethink things I once took for granted.

I’m a tech professional who works with AI every single day.
Agents — including the recently viral OpenClaw — and various AI skills have become essential to my workflow.

I once deeply studied prompt courses. I spent 3 months memorizing prompt frameworks, testing 100+ templates, and even paid for a $299 “expert prompt course” to “outsmart AI.”
We live in a fast‑moving world that wants to go even faster. A clever prompt promised to get me what I wanted from AI instantly.

I never questioned the value of prompts. I spent hours mastering complex, layered prompt structures.

That all changed after listening to their discussion.

“The Hottest New Programming Language Is English”

“I just sit there stupidly talking to the computer because I know that this thing is now at the stage where it is going to adapt to me faster than I can adapt to it.”

Outside, prompt courses are everywhere, promising superpowers.
However, Naval — one of Silicon Valley’s sharpest thinkers — says he doesn’t study any of it. He just talks to AI in plain, natural language.

At first, it sounds almost dismissive. Is this just a hook to keep you listening?
But as you dive deeper, you realize his judgment is brutally clear:
In the AI era, workflows and tooling have extremely short lifespans — months, sometimes even weeks.

The prompt template you spent weeks perfecting today may become obsolete on the next model update, just three months from now.

You spend time adapting to the model. But the model is also iterating nonstop, adapting to you.

The real question is:
Who adapts faster?

The answer is obvious: the model.

So Naval’s “laziness” is actually extreme judgment.
In an era of relentless change, what’s truly worth your time is structured thinking and the ability to clearly articulate what you want.
Those are timeless skills.

“No Entrepreneur Is Worried About AI Taking Their Job”

This second idea resonated deeply with me.

First, a tricky one: entrepreneurship isn’t a job, So AI can’t replace it.

Entrepreneurship is about creating something you want in the world, building scalable systems around it, bringing it to market, and delivering value.

It’s far harder than any job. AI can only be a helper, an ally.

If you’re an entrepreneur, you have nothing to fear.

Second, what does AI lack, compared to humans — to developers, to scientists?

It has no genuine desire of its own.

AI has no survival instinct, no sense of self — not yet, at least.
It doesn’t fear being turned off. It cannot truly be an entrepreneur.

The biggest difference between an entrepreneur and an engineer?
The former has a powerful sense of agency. They have somewhere they desperately want to go, something unique they want to fulfill. An engineer executes defined tasks — which means they can be replaced.

In the AI era, anyone who knows what they want and pursues it wholeheartedly will only be accelerated by AI, not threatened.

It’s a harsh truth. (And yes, I am an engineer)

“AI Fails the Only True Test of Intelligence.”

“The only true test of intelligence is if you get what you want out of life.”

Naval says this is one of his most widely shared tweets.
And it hits hard.

Many people go to top schools, have strong skills, but still live unhappy lives:
struggling with relationships, failing at healthy habits, not earning what they want.

Now apply that standard to AI.
It doesn’t work at all — because AI doesn’t want anything.

Here’s a spicy twist:
Most things we want in life are competitive.
If you want to win someone over, you compete with others.
If you use AI to invest, it competes with other investors and their AIs.

When everyone uses AI, the marginal advantage fades away.
The people who win in the end are still those who know what they truly want.

At the end of the discussion, one line stood out above all:

“The means of learning are abundant. It’s the desire to learn that’s scarce.”

In the AI era, you can learn almost anything by simply asking.
AI can explain a concept in 100 different ways until you understand.
You can master any skill you set your mind to.

But this only matters for one kind of person:
someone who actually wants to learn.

No amount of resources matters without desire.

This episode isn’t just about AI.
It’s about the relationship between humans and machines.
Will AI replace us? Will AI surpass us?

Behind all those questions lies the one that matters most:

We’re building increasingly advanced models and agents.
But as humans, what do we really want?

When you face AI, what do you want?

It may be the first question we must answer before we can truly remain human in the AI era.

Building a Smart, AI-Powered Book Search App — The Easy Way

Echo.lee — Wed, 18 Mar 2026 06:21:39 +0000

Just spent some time getting hands-on with seekdb, and it’s been a pleasant surprise—here’s a quick breakdown of what caught my eye (no fluff, just the good stuff):

✅ Lightweight & easy to spin up: Runs smoothly on my MacBook via Docker Desktop, or straight up with pip on Linux. macOS/Windows native support is on the way, so soon it’ll be a simple one-command install, no Docker required.

✅ Unified architecture done right: Natively supports relational, vector, full-text, JSON, and GIS data types—all indexes update atomically in the same transaction. Zero Data Lag, strict ACID compliance, and none of the latency/inconsistency headaches from traditional CDC sync.

✅ AI-Native out of the box: Built-in embedding models and AI functions mean one SQL query handles vector + full-text + scalar filtering. No more messy glue code to stitch tech stacks together—perfect for powering RAG workflows.

✅ Schema-free API: Write directly, no need to predefine rigid table structures—saves so much setup time.

✅ Full MySQL compatibility: Easy upgrade path for traditional databases looking to add AI capabilities without a complete overhaul.

✅ Open-source (Apache 2.0) with OceanBase backing: Long-term support is locked in, and the project’s only getting better—always a win for the community.

In this tutorial, we'll build an intelligent book search application from scratch using seekdb, demonstrating semantic search, hybrid search, and other core capabilities.

What We'll Build

This tutorial will walk you through creating a smart book search app that demonstrates seekdb's main features:

1. Data Import

Import from CSV files into seekdb
Support batch data import
Automatically convert book text information into 384-dimensional vector embeddings

2. Three Search Capabilities

Semantic Search: Based on vector similarity, use natural language queries to find semantically related books
Metadata Filtering: Precise filtering by rating, genre, year, price, and other fields
Hybrid Search: Combines semantic search + metadata filtering using RRF (Reciprocal Rank Fusion) algorithm

3. Index Optimization

Create HNSW vector indexes to boost semantic search performance
Generate column indexes from metadata (extract fields from JSON to create indexes)

4. Tech Stack

Database: seekdb, pyseekdb (seekdb's Python SDK), pymysql
Data Processing: pandas

Prerequisites

1. Install OrbStack

OrbStack is a lightweight Docker alternative optimized for Mac. It starts fast and uses fewer resources. We'll use it to deploy seekdb locally.

Step 1: Install via Homebrew (Recommended)

brew install orbstack

Or download from the official website: https://orbstack.dev

Step 2: Start OrbStack

# Start OrbStack
open -a OrbStack

# Verify installation
orb version

2. Deploy seekdb Image

If downloads are slow, configure Docker to use a domestic mirror source in OrbStack settings.

# Pull seekdb image
docker pull oceanbase/seekdb:latest

# Start seekdb container
docker run -d \
  --name seekdb \
  -p 2881:2881 \
  -e MODE=slim \
  oceanbase/seekdb:latest

# Check container status
docker ps | grep seekdb

# View logs (ensure service started successfully)
docker logs seekdb

Wait about 30 seconds for seekdb to fully start. You can monitor the startup logs with docker logs -f seekdb. When you see "boot success", it's ready.

3. Download the Dataset

Download the dataset from: https://www.kaggle.com/datasets/sootersaalu/amazon-top-50-bestselling-books-2009-2019

Rename it to: bestsellers_with_categories.csv. It contains 550 records of Amazon's historical bestsellers.

4. Download the Tutorial Code

git clone https://github.com/kejun/demo-seekdb-hybridsearch.git

Project Structure:

demo-seekdb-books-hybrid-search/
├── database/
│   ├── db_client.py      # Database client wrapper
│   └── index_manager.py  # Index manager
├── data/
│   └── processor.py      # Data processor
├── models/
│   └── book_metadata.py  # Book metadata model
├── utils/
│   └── text_utils.py     # Text processing utilities
├── import_data.py        # Data import script
├── hybrid_search.py      # Hybrid search demo
└── bestsellers_with_categories.csv  # Data file

Create Python Virtual Environment:

# Create virtual environment
python3 -m venv venv

# Activate virtual environment
source venv/bin/activate   # macOS/Linux
# or
.\venv\Scripts\activate    # Windows

Install Dependencies:

pip install -r requirements.txt

Execution Results

Run python import_data.py to import data. You'll see the entire process: load data file → connect to database → create database → create collection → batch import data → create metadata indexes.

(Note: seekdb currently supports HNSW indexes for embedding columns and full-text indexes for document columns. Metadata field indexing is planned for future releases.)

seekdb uses a schema-free interface design. For example, in data/processor.py, when calling collection.add(), you can pass any dictionary directly:

collection.add(
    ids=valid_ids,
    documents=valid_documents,
    metadatas=valid_metadatas  # Pass dictionary list directly, no schema predefinition needed
)

Complete Results (abbreviated):

Loading data file: bestsellers_with_categories.csv
Data loaded!
- Total rows: 550
- Total columns: 7
- Column names: Name, Author, User Rating, Reviews, Price, Year, Genre
- Load time: 0.01 seconds

Connecting to database...
Host: 127.0.0.1:2881
Database: demo_books
Collection: book_info
Database ready
Database connection successful

Creating/rebuilding collection...
Collection name: book_info
Vector dimensions: 384
Distance metric: cosine
Collection created successfully

Processing data...
Data preprocessing complete!
- Total records: 550
- Validation errors: 0
- Processing time: 0.05 seconds

Importing data to collection...
- Batch size: 100
- Total batches: 6
- Starting import...

Import progress: 100%|█████████████████████████████████████| 6/6 [00:53<00:00,  8.97s/batch]

Data import complete!
- Import time: 53.83 seconds
- Average speed: 10 records/second

Creating metadata indexes...
- Index fields: genre, year, user_rating, author, reviews, price
Index creation complete!
- Creation time: 3.81 seconds

Data import process complete!
Total time: 59.64 seconds
Imported records: 550
Database: demo_books
Collection: book_info

After importing data, you can query the database directly using the MySQL client or install obclient in the terminal.

# Enter seekdb container
docker exec -it seekdb bash

# Connect using MySQL client (seekdb is MySQL-compatible)
mysql -h127.0.0.1 -P2881 -uroot

book_info is a seekdb collection, which corresponds to the underlying table name c$v1$book_info:

-- View all databases
SHOW DATABASES;

-- Switch to demo database
USE demo;

-- View all tables (collections)
SHOW TABLES;

-- View collection structure
DESC c$v1$book_info;

-- Query collection data
SELECT * FROM c$v1$book_info LIMIT 10;

-- Count records
SELECT COUNT(*) FROM c$v1$book_info;

-- Exit
EXIT;

show table schemaDESC c$v1$book_info：

show index created：

(Note: pyseekdb doesn't currently support direct indexing of metadata columns, so the project uses pymysql + SQL DDL to implement metadata indexing. The next pyseekdb version will support automatic indexing of metadata fields.)

Running Hybrid Search

Next, run python hybrid_search.py. seekdb's built-in embedding model is sentence-transformers/all-MiniLM-L6-v2, with a maximum vector dimension of 384. For better results, configure an external model service.

Hybrid search is seekdb's killer feature. It simultaneously executes full-text retrieval and vector retrieval, then merges results using the RRF (Reciprocal Rank Fusion) algorithm.

Looking at the code example, query_params defines a full-text search for "inspirational" while filtering by user rating (user_rating >= 4.5) from metadata. knn_params is semantic search, with query_texts being the phrase "inspirational life advice", using the same user rating filter.

Code Snippet:

query_params = {
    "where_document": {"$contains": "inspirational"},
    "where": {"user_rating": {"$gte": 4.5}},
    "n_results": 5
}
knn_params = {
    "query_texts": ["inspirational life advice"],
    "where": {"user_rating": {"$gte": 4.5}},
    "n_results": 5
}

results = collection.hybrid_search(
    query=query_params,
    knn=knn_params,
    rank={"rrf": {}},
    n_results=5,
    include=["metadatas", "documents", "distances"]
)

The results are impressively accurate. Complete execution results (abbreviated):

=== Semantic Search ===
Query: ['self improvement motivation success']

Semantic Search - Found 5 results:

[1] The 7 Habits of Highly Effective People: Powerful Lessons in Personal Change
    Author: Stephen R. Covey
    Rating: 4.6
    Reviews: 9325
    Price: $24.0
    Year: 2011
    Genre: Non Fiction
    Similarity distance: 0.5358
    Similarity: 0.4642

(Other results omitted...)


=== Hybrid Search (Rating≥4.5) ===
Query: {'where_document': {'$contains': 'inspirational'}, 'where': {'user_rating': {'$gte': 4.5}}, 'n_results': 5}
KNN Query Texts: ['inspirational life advice']

Hybrid Search (Rating≥4.5) - Found 5 results:

[1] Mindset: The New Psychology of Success
    Author: Carol S. Dweck
    Rating: 4.6
    Reviews: 5542
    Price: $10.0
    Year: 2014
    Genre: Non Fiction
    Similarity distance: 0.0159
    Similarity: 0.9841

(Other results omitted...)


=== Hybrid Search (Non Fiction) ===
Query: {'where_document': {'$contains': 'business'}, 'where': {'genre': 'Non Fiction'}, 'n_results': 5}
KNN Query Texts: ['business entrepreneurship leadership']

Hybrid Search (Non Fiction) - Found 5 results:

[1] The Five Dysfunctions of a Team: A Leadership Fable
    Author: Patrick Lencioni
    Rating: 4.6
    Reviews: 3207
    Price: $6.0
    Year: 2009
    Genre: Non Fiction
    Similarity distance: 0.0164
    Similarity: 0.9836

(Other results omitted...)


=== Hybrid Search (Fiction, After 2015, Rating≥4.0) ===
Query: {'where_document': {'$contains': 'fiction'}, 'where': {'$and': [{'year': {'$gte': 2015}}, {'user_rating': {'$gte': 4.0}}, {'genre': 'Fiction'}]}, 'n_results': 5}
KNN Query Texts: ['fiction story novel']

Hybrid Search (Fiction, After 2015, Rating≥4.0) - Found 5 results:

[1] A Gentleman in Moscow: A Novel
    Author: Amor Towles
    Rating: 4.7
    Reviews: 19699
    Price: $15.0
    Year: 2017
    Genre: Fiction
    Similarity distance: 0.0154
    Similarity: 0.9846

(Other results omitted...)


=== Hybrid Search (Reviews≥10000) ===
Query: {'where_document': {'$contains': 'popular'}, 'where': {'reviews': {'$gte': 10000}}, 'n_results': 10}
KNN Query Texts: ['popular bestseller']

Hybrid Search (Reviews≥10000) - Found 10 results:

[1] Twilight (The Twilight Saga, Book 1)
    Author: Stephenie Meyer
    Rating: 4.7
    Reviews: 11676
    Price: $9.0
    Year: 2009
    Genre: Fiction
    Similarity distance: 0.0143
    Similarity: 0.9857

[2] 1984 (Signet Classics)
    Author: George Orwell
    Rating: 4.7
    Reviews: 21424
    Price: $6.0
    Year: 2017
    Genre: Fiction
    Similarity distance: 0.0145
    Similarity: 0.9855

[3] Last Week Tonight with John Oliver Presents A Day in the Life of Marlon Bundo (Better Bundo Book, LGBT Childrens Book)
    Author: Jill Twiss
    Rating: 4.9
    Reviews: 11881
    Price: $13.0
    Year: 2018
    Genre: Fiction
    Similarity distance: 0.0147
    Similarity: 0.9853

(Other results omitted...)

Vibe Coding Friendly

If you're using Cursor or Claude Code for development, you've probably installed context7-mcp. It queries the latest API documentation, code examples, and more—the perfect companion for vibe coding. I noticed seekdb has been added to Context7:

seekdb: https://context7.com/oceanbase/seekdb
pyseekdb: https://context7.com/oceanbase/pyseekdb

If you haven't installed it yet, I highly recommend it:

{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": [
        "-y",
        "@upstash/context7-mcp",
        "--api-key",
        "<your-apiKey-created-on-context7>"
      ]
    }
  }
}

After installation, you can learn and use seekdb simultaneously.

Key Takeaways

What makes seekdb special:

Lightweight & Easy to Deploy: Runs smoothly on a MacBook, with native macOS/Windows support coming soon
Unified Architecture: Combines relational, vector, full-text, JSON, and GIS in one system
AI-Native: Built-in embeddings and AI functions, no glue code needed
Schema-Free: Write directly without predefining schemas
MySQL-Compatible: Easy migration path for existing databases
Open Source: Apache 2.0 license with OceanBase backing

The hybrid search capability is particularly impressive—combining semantic understanding with precise metadata filtering delivers results that feel both intelligent and accurate.

Repo: github.com/oceanbase/seekdb (Apache 2.0 — Stars, Issues, PRs welcome)
Docs: seekdb documentation
Discord: https://discord.com/channels/1331061822945624085/1331061823465590805
Medium:https://medium/seekdb
Press: OceanBase Releases seekdb (MarkTechPost)

I hope this tutorial helps you get started with seekdb more smoothly. Enjoy building! 🚀

Beyond Text: seekdb Does Travel, Image Search, and Voice—in One DB

Echo.lee — Tue, 17 Mar 2026 02:32:13 +0000

Keywords: TEN · PowerMem · travel · image search · voice assistant

Hybrid search isn’t just for text. You can store and query multimodal data—images, text, spatial data—in one database. seekdb’s multimodal and GIS support live in the open-source repo; there’s no “enterprise-only” tier. This post walks through three scenarios: a cultural-tourism assistant (multimodal fusion), image search, and a TEN + PowerMem voice assistant. For each, we focus on what seekdb solves and the one step that matters most.

1. Travel Assistant: Multimodal Fusion in One Database

Scenario: Attractions, exhibits, routes—with text descriptions, images, and locations (GIS). Users might ask in natural language (“What’s nearby?” or “Anything worth seeing around here?”) or upload a photo (“What else looks like this?” or “Where else can I find places like this?”).

What seekdb does

Puts text, image vectors, and spatial data in one store: relational fields (name, tags), vector columns (text/image embeddings), full-text columns (descriptions), and GIS columns (coordinates or regions).
At query time, vector similarity (semantic + image search) + full-text keywords + spatial filters run in a single request—no “query the image store, then the business DB, and then merge.”

The one step that matters: When you model your data, define “one record” clearly (e.g. one row per attraction) so vector, full-text, and GIS stay in sync. Then, from whatever the front end sends—text query, image, or location—build one hybrid query.

For the full walkthrough, see Build a cultural tourism assistant with seekdb multi-model integration.

2. Image Search: Architecture and Key APIs

Scenario: User uploads an image; the system returns the “semantically closest” images in the store (same style, same scene, etc.).

What seekdb does

Images go through a vision model to get vectors and are written into seekdb’s vector column; you can also store image URLs, tags, and other relational/full-text fields.
At query time: upload image → same vision model → query vector → vector search (or hybrid: vector + tag keywords) in seekdb → return results by similarity.

The one step that matters: Pick a vision embedding model and vector dimension, create a VECTOR INDEX, and optionally add full-text/tags for hybrid “image + text” search in one request.

Full example: Build an image search application with seekdb.

3. TEN + PowerMem Voice Assistant

Scenario: A voice-driven agent—speech input → ASR → understanding and retrieval (possibly multi-turn, with memory) → reply generation → TTS. “Memory” and “retrieval” need a stable, low-latency storage and retrieval layer.

What seekdb does

The TEN framework handles dialogue orchestration, multi-turn logic, and tasks; OceanBase PowerMem handles memory/state and retrieval.
seekdb is the unified storage and retrieval backend: conversation summaries, user preferences, knowledge snippets. Hybrid search supports recall by semantics, by keywords, and by relations, so the agent can decide what to say and generate replies from one place.

The one step that matters: Model “what to remember” and “what to retrieve” as seekdb tables (relational + vector + full-text). Each turn: write into memory as needed, run hybrid retrieval as needed, and then hand off to LLM/TTS.

See Build a personalized voice assistant with TEN Framework and OceanBase PowerMem.

4. Summary: Multimodal = One DB, Multiple Indexes, One Query

Here, “multimodal” means: one store and transaction model; vector, full-text, and GIS indexes kept in sync; and one query that expresses multiple intents. This is the first post in our “seekdb magic” series. More demos are on the way—fun, useful, and built to make your work and life a bit easier. Join us and try them out.

Repo: github.com/oceanbase/seekdb (Apache 2.0 — Stars, Issues, PRs welcome)
Docs: seekdb documentation
Discord: https://discord.com/channels/1331061822945624085/1331061823465590805
Medium: https://dev.to/seekdb
Press: OceanBase Releases seekdb (MarkTechPost)

No SQL Required: Build AI Apps & Knowledge Bases with Plain Language

Echo.lee — Thu, 12 Mar 2026 06:33:30 +0000

Imagine this: you describe what you need in plain English, and AI automatically handles all the database operations—creating document collections, inserting data, running complex queries, even building a complete knowledge base application. This isn't science fiction. It's available right now.

seekdb MCP Server is the bridge that makes this possible. Built on Anthropic's Model Context Protocol (MCP), it enables AI assistants to interact directly with SeekDB databases, transforming natural language into database operations seamlessly.

In this guide, we'll walk you through seekdb MCP Server and build a real-world AI application using nothing but natural language. You'll experience firsthand what it means to work with an AI-native database.

What is seekdb MCP Server?

seekdb is an AI-native search database that unifies relational data, vector data, full-text indexing, JSON, and GIS capabilities in a single architecture. It supports hybrid retrieval and in-database AI workflows.

MCP Server acts as the "adapter" connecting AI tools to databases. Through the MCP protocol, AI tools like Cursor, Claude Code, and Cline can directly access and manipulate SeekDB databases.

Core Capabilities at a Glance

Category	Tools	What It Does
Vector Collection Management	`create_collection`, `query_collection`, `add_data_to_collection`	Create vector collections, semantic search, document management
Advanced Search	`full_text_search`, `hybrid_search`	Full-text search, hybrid search (BM25 + vectors)
AI Functions	`ai_complete`, `ai_rerank`, `create_ai_model`	Call LLMs for text generation, rerank search results
AI Memory System	`seekdb_memory_query`, `seekdb_memory_insert`	Persistent cross-session memory—AI that remembers you
Data Import/Export	`import_csv_file_to_seekdb`, `export_csv_file_from_seekdb`	Convert between CSV files and database tables/vector collections

Installing seekdb Database

Before using seekdb MCP Server, you'll need to set up seekdb. seekdb offers two deployment modes:

Mode 1: Embedded Mode (Zero Configuration, Linux Only)

No separate installation needed! SeekDB MCP Server automatically initializes a local embedded database when it starts—truly plug-and-play.

Best for: Personal learning, rapid prototyping, edge device deployment.

⚠️ Note for macOS and Windows users: You'll need to use Client/Server mode. Deploy SeekDB first (Docker recommended), then configure connection parameters.

Mode 2: Client/Server Mode (Recommended for Production)

For test or production environments, choose one of these options:

Option 1: Install via yum (RPM systems)

# 1. Add seekdb repository
sudo yum-config-manager --add-repo https://mirrors.aliyun.com/oceanbase/OceanBase.repo

# 2. Install seekdb and client
sudo yum install seekdb obclient

# 3. Start seekdb
sudo systemctl start seekdb

# 4. Check status (look for "Service is ready")
sudo systemctl status seekdb

# 5. Test connection
mysql -h127.0.0.1 -uroot -P2881 -A oceanbase

Option 2: Use Docker (Fastest)

# One command to start seekdb
sudo docker run -d -p 2881:2881 oceanbase/seekdb

# If pull fails, try alternative mirrors:
# sudo docker run -d -p 2881:2881 quay.io/oceanbase/seekdb
# sudo docker run -d -p 2881:2881 ghcr.io/oceanbase/seekdb

System Requirements:

CPU: Minimum 1 core
Memory: Minimum 2 GB available
Supported OS: CentOS 7/8, Ubuntu 20+, Debian 9+, Anolis OS 8, Kylin V10, and more

For more deployment options, check the SeekDB deployment documentation.

Installing seekdb MCP Server

Install uv Package Manager

# Install uv package manager
curl -LsSf https://astral.sh/uv/install.sh | sh

Configuring AI Tool Connection

Stdio Mode

Using Cursor as an example: Open Settings → Tools & MCP → New MCP Server, then choose your configuration based on your OS:

Linux Users (Embedded Mode)

{
  "mcpServers": {
    "seekdb": {
      "command": "uvx",
      "args": ["seekdb-mcp-server"]
    }
  }
}

That's it! Embedded mode requires zero configuration—the server automatically initializes a local seekdb database on startup.

macOS / Windows Users (Server Mode)

macOS and Windows don't support embedded mode. Deploy SeekDB first (Docker recommended), then configure connection parameters:

{
  "mcpServers": {
    "seekdb": {
      "command": "uvx",
      "args": ["seekdb-mcp-server"],
      "env": {
        "SEEKDB_HOST": "127.0.0.1",
        "SEEKDB_PORT": "2881",
        "SEEKDB_USER": "",
        "SEEKDB_PASSWORD": "",
        "SEEKDB_DATABASE": "test"
      }
    }
  }
}

Parameter Reference:

Parameter	Description	Default
`SEEKDB_HOST`	seekdb server address	`127.0.0.1`
`SEEKDB_PORT`	seekdb service port	`2881`
`SEEKDB_USER`	Database username	None
`SEEKDB_PASSWORD`	Database password	None
`SEEKDB_DATABASE`	Database name	None

SSE Mode

Linux Users (Embedded Mode)

Start the SSE server directly:

uvx seekdb-mcp-server --transport sse --port 6000

macOS / Windows Users (Server Mode)

Configure environment variables first, then start the server:

# Configure SeekDB connection info
export SEEKDB_HOST=127.0.0.1
export SEEKDB_PORT=2881
export SEEKDB_USER=
export SEEKDB_PASSWORD=
export SEEKDB_DATABASE=test

# Start SSE server
uvx seekdb-mcp-server --transport sse --port 6000

Then configure the client:

{
  "sse-seekdb": {
    "type": "sse",
    "url": "http://127.0.0.1:6000/sse"
  }
}

Hands-On: Building a Personal Notes Knowledge Base with AI

Let's build a complete real-world example to experience SeekDB MCP Server's power. We'll create a personal notes knowledge base that can:

✅ Store notes using natural language
✅ Search content semantically
✅ Use hybrid search for precise results
✅ Answer questions intelligently with AI

Scenario

You're a tech professional who takes notes on learning materials and work insights. You want AI to help manage these notes and quickly find what you need using natural language.

Step 1: Create a Notes Collection

In your AI tool (like Cursor), type:

Create a knowledge base collection named "my_notes"

AI Response Example:

I've successfully created a collection named "my_notes":

Dimensions: 384 (vector size)
Distance Metric: L2 (Euclidean distance)

Just like that, you have a vector collection ready for semantic search!

Step 2: Add Note Content

Continue with:

Add the following notes to my_notes:

1. "seekdb supports hybrid retrieval combining vector search and full-text search, leveraging both keyword matching and semantic understanding"
2. "MCP protocol is an open-source protocol proposed by Anthropic in November 2024, enabling large models to interact with external tools"
3. "Python's asyncio module provides asynchronous programming capabilities, ideal for I/O-intensive tasks"
4. "Docker containerization enables rapid application deployment and environment isolation"
5. "RAG (Retrieval-Augmented Generation) is the most popular AI application architecture today, combining retrieval and generation capabilities"

AI Response Example:

Done! Successfully added 5 notes to the "my_notes" collection:

ID	Content
doc1	seekdb supports hybrid retrieval combining vector search...
doc2	MCP protocol is an open-source protocol proposed by Anthropic...
doc3	Python's asyncio module provides asynchronous programming...
doc4	Docker containerization enables rapid application deployment...
doc5	RAG (Retrieval-Augmented Generation) is the most popular...

Step 3: Semantic Search

Now, let's search your notes using natural language:

Search my_notes for notes related to "AI application development"

AI Response Example:

Here are notes related to "AI application development", sorted by relevance:

Rank	Content	Relevance
1	RAG (Retrieval-Augmented Generation) is the most popular AI application architecture...	Highest
2	MCP protocol is an open-source protocol proposed by Anthropic in November 2024...	High
3	seekdb supports hybrid retrieval combining vector search and full-text search...	Medium

Notice: we searched for "AI application development," but that exact phrase doesn't appear in any note. SeekDB's vector search understands semantic similarity and automatically finds relevant content!

Step 4: Hybrid Search

Hybrid search combines keyword matching and semantic understanding for more accurate results:

Perform a hybrid search on my_notes:
- Full-text keyword: "Python"
- Semantic query: "asynchronous programming and concurrency"

AI Response Example:

Rank	Content
1	Python's asyncio module provides asynchronous programming capabilities, ideal for I/O-intensive tasks
2	Docker containerization enables rapid application deployment and environment isolation

Hybrid search uses the RRF (Reciprocal Rank Fusion) algorithm, combining keyword matching (BM25) scores with vector similarity scores for more accurate rankings.

Step 5: Make AI Remember Your Preferences

seekdb MCP Server also provides an AI Memory System that lets AI remember your information across sessions:

Remember that I'm a Python developer who primarily uses SeekDB for vector search applications

AI Response Example:

Recorded! I'll remember:

You're a Python developer
You primarily use SeekDB for vector search applications

In future conversations, you can ask:

Based on my technical background, recommend some learning resources

AI will automatically retrieve your preferences and provide personalized recommendations!

Complete Feature Reference

Vector Collection Management

Tool	Function
`create_collection`	Create a vector collection
`list_collections`	List all collections
`has_collection`	Check if a collection exists
`peek_collection`	Preview documents in a collection
`add_data_to_collection`	Add documents (auto-generates vectors)
`update_collection`	Update documents
`delete_documents`	Delete documents
`query_collection`	Vector similarity search
`delete_collection`	Delete a collection

Advanced Search

Tool	Function
`full_text_search`	Full-text search (keyword-based)
`hybrid_search`	Hybrid search (combines full-text and vector search)

AI Model Tools

Tool	Function
`create_ai_model`	Register an AI model (embedding, text generation, or reranking)
`create_ai_model_endpoint`	Create an endpoint connecting a model to an API service
`drop_ai_model`	Remove a registered AI model
`drop_ai_model_endpoint`	Remove an AI model endpoint
`ai_complete`	Call an LLM for text generation
`ai_rerank`	Use an AI model to rerank documents by relevance
`get_registered_ai_models`	List all registered AI models
`get_ai_model_endpoints`	List all AI model endpoints

AI Memory System

SeekDB MCP Server provides powerful AI memory capabilities, enabling AI assistants to remember information across sessions:

Tool	Function
`seekdb_memory_query`	Semantic search memories
`seekdb_memory_insert`	Store new memories
`seekdb_memory_update`	Update memories
`seekdb_memory_delete`	Delete memories

Use Cases:

AI remembers your tech stack preferences (e.g., "I prefer Python")
AI remembers project information (e.g., "This project uses FastAPI")
AI remembers personal preferences (e.g., "I like clean code style")

Data Import/Export

Tool	Function
`import_csv_file_to_seekdb`	Import CSV files
`export_csv_file_from_seekdb`	Export data to CSV

SQL Operations

Tool	Function
`execute_sql`	Execute SQL queries
`get_current_time`	Get database current time

Exploring More Tools

Beyond what we've covered, SeekDB MCP Server also supports:

AI Function Calls
- Use AI models to analyze sentiment: "The weather is great today, I'm in a good mood!"
CSV Data Import
- Import /path/to/products.csv as a vector collection, using column 2 (product descriptions) as documents

FAQ

Q: Do I need to install seekdb separately?

A: No! seekdb MCP Server uses embedded mode—SeekDB is included, no separate installation needed.

Q: Where is data stored?

A: Data is stored in your local file system, defaulting to your home directory. Your data stays completely local—nothing is uploaded to the cloud.

Q: Which operating systems are supported?

A: Currently supports Linux (glibc >= 2.28), with support for x86_64 and aarch64 architectures.

Q: How do I upgrade?

A: Using uvx automatically uses the latest version.

The Bottom Line

SeekDB MCP Server makes database operations simpler than ever:

Traditional Way	MCP Way
Learn SQL syntax	Describe needs in natural language
Write code to call APIs	AI automatically executes operations
Manually manage vector embeddings	Auto-generate and index
Handle search logic separately	One command for hybrid search

Whether you're building RAG applications or giving your AI assistant long-term memory, seekdb MCP Server is your best bet.

Resources:

⭐ Repo: github.com/oceanbase/seekdb (Apache 2.0)
📖 Docs: SeekDB Documentation
💬 Discord: Join our community
🐦 Follow us: @seekdb

Start your AI-native database journey today! 🚀

Building RAG & Knowledge Bases with seekdb: Three Paths, One Stack

Echo.lee — Wed, 11 Mar 2026 07:55:14 +0000

The real headache in RAG isn’t retrieval or generation—it’s the layer in between. Where does the data live? How do you keep it in sync? Who glues it all together? seekdb and Dify are both open-source. Your RAG stack—from storage to orchestration—can be self-hosted, auditable, and customizable, without locking you into closed services. This post walks through three paths, all built on one stack: RAG from scratch with seekdb, Dify + seekdb, and a knowledge base desktop app. Pick the one that fits and get it running.

In the mesh of light, a patch that fits.

Where seekdb Fits in the RAG Pipeline

A typical RAG pipeline looks like: load documents → chunk → embed → store; at query time: retrieve → (optionally) rerank → feed to LLM → generate. If your storage is a patchwork of MySQL + vector DB + full-text engine, you end up managing sync, multi-source queries, and fusion yourself. seekdb’s role: one database that holds relational data, vectors, and full-text in the same place. Write once, index automatically; one hybrid query returns results. You can use in-database AI functions for embedding and reranking when needed, so storage and retrieval live in one layer with less glue code.

Three paths we’ll cover:

RAG from scratch with seekdb — Best if you want full control over the pipeline or already have a Python/app stack.
Dify + seekdb — Best if you want Dify for orchestration and UI and seekdb as the knowledge-base backend, collapsing the stack to Dify config + seekdb storage.
Knowledge base desktop application — Best if you want a local, multi-project desktop app with seekdb as the backend and a custom frontend.

Path 1: RAG from Scratch with seekdb (Summary)

1. Deploy and create tables

Run seekdb in Embedded or Client/Server mode. Create a table (or Python collection) with vector + full-text columns, and create a VECTOR INDEX and FULLTEXT INDEX.

2. Load documents

Read docs (PDF, TXT, MD, etc.) → chunk them (by paragraph, by length, with overlap, etc.).
For each chunk, call your embedding model to get a vector (use seekdb’s in-database AI functions, or compute in your app and insert into seekdb).
INSERT into seekdb: each row has chunk text, vector, and any metadata you need (source, doc id, segment id, etc.).

3. At query time

Turn the user question into a query vector (same embedding).
Use hybrid search: vector_query + full_text_query(optional) + relational filters (e.g. by knowledge-base id), and take top_k candidates.
Optional: rerank with seekdb or in your app → pass the final context to your LLM to generate the answer.

4. Things to watch

Chunking strategy and chunk size directly affect recall; pick one and tune from there.
If you use in-database AI for embedding/reranking, you save a round-trip to external services.
For full steps and code, see Build a RAG application with seekdb.

Path 2: Dify + seekdb — Collapse the RAG Stack (Both Open-Source)

Dify handles workflow orchestration, knowledge-base setup, and the chat UI. The data source can be seekdb: Dify’s pipeline does “upload/parse → chunk → embed → write,” while storage and retrieval happen in seekdb—with strong consistency, hybrid search, and in-database AI. Dify and seekdb are both open-source, so the whole RAG stack can be self-hosted, audited, and extended. Good fit if you care about data and architecture ownership.

Configuration idea (check your Dify version for exact UI):

In Dify, set the knowledge base data source to seekdb (or wire seekdb via Dify’s supported vector store/API).
After you upload documents, Dify parses and chunks them, calls the embedding service, and writes into seekdb. At query time, Dify sends the query to seekdb, gets hybrid-search results back, and passes them to the LLM node for the final answer.

Result: no separate sync scripts or multi-database juggling—the stack is just “Dify config + seekdb.” For details, see Dify + seekdb: Collapsing the RAG Stack.

Path 3: Knowledge Base Desktop App — Local, Multi-Project

If you'd rather skip Dify and want a local knowledge base desktop application (multiple projects, multiple docs, local search): use seekdb as the backend and a desktop client (e.g. Tauri or Electron + your frontend) to connect to seekdb's API. The flow is the same: parse → chunk → embed → write to seekdb; at query time use hybrid search and show results or feed them to a local LLM.

There’s an official guide: Building a knowledge-base desktop app with seekdb—it outlines the stack and steps.

Which Path to Choose?

Once you've got RAG or a knowledge base running with seekdb, you might wonder where it goes next. In the next post we'll take seekdb beyond text: multimodal and agents—think travel assistant, image search, TEN+PowerMem voice assistant—and how the same stack extends to those scenarios.

Repo: github.com/oceanbase/seekdb (Apache 2.0 — Stars, Issues, PRs welcome)
Docs: seekdb documentation
Discord: https://discord.com/channels/1331061822945624085/1331061823465590805
Medium: https://medium/seekdb
Press: OceanBase Releases seekdb (MarkTechPost)

Building RAG or an AI workflow? What’s the one thing you wish your database did better—or didn’t do at all? Drop it in the comments. We read them, and the next features we ship often come from exactly those pain points. Open source only gets better when people say what’s broken.

Get Started with seekdb_ Install, Deploy, and Run Your First Hybrid Search

Echo.lee — Mon, 09 Mar 2026 07:05:40 +0000

Hi, still remember the question we raised in the last post? Here is the answer: From installation to your first hybrid-search result in about ten minutes. seekdb’s packages, SDKs, and docs are open source—no closed-source bits, just what you see on GitHub. This post walks through both Embedded and Client/Server in a “run it first, then code” order, with copy-paste hybrid-search examples for each.

AI future corridor

1. Two Ways to Run It—Pick One

Method	Scenario	In one sentence
Embedded (Python SDK)	Local dev, prototypes, small apps, resource-constrained	One `pip install`; seekdb runs in your process, no separate server.
Client/Server + SQL	Multi-language, multi-process, or MySQL client	Run the seekdb service; connect via SQL or any language client.

Most people start with Embedded + Python: zero config, one import, data in a local directory. We’ll do that first. If you’re on a Mac and prefer SQL or a MySQL client, see Section 3 (we use macOS as an example there).

2. Embedded: Up and Running in One Command

Requirements: Python 3.11+, Linux or macOS (Embedded is not supported on Windows; use Server mode there).

pip install -U pyseekdb

Once installed, seekdb runs as an embedded library with your process. Data is stored locally; no separate service to deploy.

Step 1: Connect and get a collection

import pyseekdb

client = pyseekdb.Client()
collection = client.get_or_create_collection(name="docs")

Step 2: Add documents and run hybrid search

Add a few documents, and then query with hybrid_search. The SDK’s hybrid_search() takes a query (full-text conditions), knn (vector/semantic search), and rank (e.g. RRF fusion), and returns fused results. Section 3 shows how to do the same with SQL.

# Add documents (ids + text; embedding is handled by the collection when configured)
ids = ["doc_1", "doc_2", "doc_3"]
documents = [
    "seekdb is an AI-native hybrid search database",
    "Hybrid search combines vector and full-text in one query",
    "You can run it embedded or as a server with SQL",
]
collection.add(ids=ids, documents=documents)

# Hybrid search: full-text (keyword) + vector (semantic), fused with RRF
results = collection.hybrid_search(
    query={"where_document": {"$contains": "hybrid"}, "n_results": 10},
    knn={"query_texts": ["AI native search database"], "n_results": 10},
    rank={"rrf": {}},
    n_results=5
)

That’s it for Embedded: Client() → get_or_create_collection() → add() → hybrid_search(). (Embedding config, more filters, and full API: Python SDK get started.)

3. Client/Server: Hybrid Search over SQL

Use this when you want standard SQL or a MySQL client. Deploy the seekdb service on your machine or a server; the option depends on your platform:

Platform	Deploy option
macOS	Homebrew (`brew install seekdb`) — see Section 3.1 below.
Linux (RHEL/CentOS, Debian/Ubuntu)	Package manager (yum/apt) + systemd, or Docker.
Windows	OceanBase Desktop or Docker.

For a whole picture of deployment options, see Deployment overview.

3.1 Deploy on macOS (Homebrew)

Note: The steps in this section use macOS (Homebrew) as an example. For Linux or Windows, follow the options in the table above.

Mac users can run seekdb in Server mode with Homebrew. This is the usual path if you’re on a Mac and want to use SQL or a MySQL client.

Prerequisites: macOS 15 or later, 1 CPU core and 2 GB memory, and a MySQL client (e.g. mysql from Homebrew).

Step 1: Install seekdb

brew tap oceanbase/seekdb
brew install seekdb

Step 2: Start seekdb

Background: seekdb-start
Foreground: seekdb --nodaemon
Custom data dir: seekdb --base-dir=/custom/path

Step 3: Connect with MySQL client

mysql -h127.0.0.1 -uroot -P2881 -p -A -Dtest

Default port is 2881; default password is empty. Once connected, you can run the SQL in Section 3.2 (create table, then hybrid search).

3.2 Create a table and run hybrid search

Create a table with vector and full-text indexes

Use a small vector dimension for a minimal runnable example. Replace with your own embedding dimension (e.g. 1536) and add VECTOR INDEX ... WITH (distance=l2, type=hnsw, lib=vsag) if needed.

CREATE TABLE doc_table (
  c1 INT,
  vector VECTOR(3),
  query VARCHAR(255),
  content VARCHAR(255),
  VECTOR INDEX idx_vec(vector) WITH (distance=l2, type=hnsw, lib=vsag),
  FULLTEXT INDEX idx_ft_query(query),
  FULLTEXT INDEX idx_ft_content(content)
) ORGANIZATION HEAP;

INSERT INTO doc_table VALUES
(1, '[1,2,3]', 'hello world', 'seekdb Elasticsearch database'),
(2, '[1,2,1]', 'hello world, what is your name', 'seekdb database'),
(3, '[1,1,1]', 'hello world, how are you', 'seekdb mysql database');

Run hybrid search via the built-in package

The hybrid search API is DBMS_HYBRID_SEARCH.SEARCH(table_name, json_param) used in a SELECT. Set a JSON parameter with query (full-text) and knn (vector), and then run:

-- Set search params: full-text (query_string) + vector (knn), then execute
SET @parm = '{
  "query": {
    "query_string": {
      "fields": ["query", "content"],
      "query": "hello seekdb"
    }
  },
  "knn": {
    "field": "vector",
    "k": 5,
    "query_vector": [1, 2, 3]
  }
}';

SELECT json_pretty(DBMS_HYBRID_SEARCH.SEARCH('doc_table', @parm));

Results come back ranked by relevance. For more parameters (e.g. boost, RRF), see Hybrid search.

4. Your First Hybrid Search: You Did Two Things

Create a table (or an SDK collection) with a vector column and a full-text index.
Send one query with a vector and keywords, and let seekdb fuse and rank inside the database (e.g. RRF).

No “query the vector store, then the full-text store, and then merge in the app”—that’s the no-stitching difference. Once this works, it’s straightforward to upload real documents, add an embedding model, and connect a RAG pipeline.

Repo: github.com/oceanbase/seekdb (Apache 2.0 — Stars, Issues, PRs welcome)
Docs: seekdb documentation
Discord: https://discord.com/channels/1331061822945624085/1331061823465590805
Press: OceanBase Releases seekdb (MarkTechPost)

We would also love to hear your stories, insights, and perspectives on the future of AI and databases. Open source is more than a development model — it’s a mindset. That’s why we choose to build openly, together with the community.

Because we truly believe: Great things start when people talk, share, and create freely.

And that’s where the magic begins.

The next post will focus on hybrid search and AI functions: tuning parameters, running embedding and reranking inside the database, and using these to build RAG quickly. Stay tuned.

Find Your Fit: When to Use seekdb

Echo.lee — Thu, 05 Mar 2026 08:54:46 +0000

Abstract: This post helps you find your scenario: who seekdb is for, how to try it, and how to get started without a full migration.

This is the second post in our seekdb series. In the first post (Stop Stitching Your RAG Stack: Why We Built seekdb), we covered the cost of stitched RAG architectures, what seekdb is, and what you stop paying for. This post doesn’t repeat that. It does one thing: helps you find your scenario, choose the right way to use seekdb, and get started.

1. Where Are You Today?

Teams are at different stages, so their needs from seekdb differ. See which of these four fits you best.

If you’re in the first two: seekdb’s “one engine, one SQL, one transaction” is built for exactly that. Worth a serious try.
If you’re in the third: No need to switch for the sake of it. Treat seekdb as an option for new projects or new use cases.
If you’re in the fourth: Strong consistency and hybrid search are seekdb’s sweet spot. Focus on in-database transactions and single-query hybrid search.

2. Who Is seekdb For?

Two lists make the boundary clear so you can find your fit.

Seekdb is a strong fit when:

You’re building RAG or semantic search from scratch and don’t want to stitch multiple databases.
You need business data and vectors/full-text updated in the same transaction.
Resources are limited (single machine or small cluster) and you want to iterate quickly.
You want one SQL for hybrid search and less fusion/rerank glue code.

If you’re already in one of these situations, your current setup may be enough (you can still keep seekdb in mind for new projects or new use cases):

You already have PB-scale vectors and need cross-DC distribution.
You only need pure vector ANN and don’t need SQL or full-text.
You’re deeply committed to a cloud vendor’s managed vector service.
You need deep, tight integration with existing Elasticsearch or Milvus clusters.

In short: seekdb is for teams that don’t want to start by stitching databases—one engine, one SQL, one transaction, get RAG and hybrid search running first. If you already have a stable distributed vector/full-text cluster and don’t have a strong need for consistency + hybrid search, your current setup is fine; consider seekdb when you start something new.

3. You Don’t Need a Full Migration: Three Ways to Try

You don’t have to “replace everything” to get value. Three common patterns:

Use it for new projects: From day one, use seekdb as storage and retrieval for a new RAG or semantic-search project. No multi-DB sync, no glue.
Try it alongside the old system: Leave the current pipeline as is; point a small slice of new data or a new feature at seekdb. Get hybrid search and in-database AI working, then decide whether to expand.
Run it locally first: pip install, run “one SQL, get results” on your machine, then consider Client-Server or plugging into your existing MySQL tooling.

The next post will walk through installation, deployment (Embedded / Client-Server), and your first hybrid-search query—from setup to that first SQL. If you’re ready to try seekdb now, you can jump straight to our docs.

Repo: github.com/oceanbase/seekdb (Apache 2.0 — Stars, Issues, PRs welcome)
Docs: seekdb documentation
Discord: https://discord.com/channels/1331061822945624085/1331061823465590805
Press: OceanBase Releases seekdb (MarkTechPost)

The open‑source journey continues. So does our exploration of databases and infrastructure built for the AI era.

As always, we’d love to hear your open‑source stories and thoughts. Maybe we can build something meaningful together. That would be a journey worth taking.❤️

And here’s a small question to leave you with: How long does it actually take to install seekdb and use it in your RAG or other AI applications?

The answer is coming tomorrow.

Stop Stitching Your RAG Stack: Why We Built seekdb

Echo.lee — Wed, 04 Mar 2026 06:49:39 +0000

Hi — we're the seekdb team. We're building seekdb, an open-source AI-native hybrid search database. This is our first post here; in the ones that follow, we'll share our story with seekdb.

If your RAG setup looks like this—MySQL for metadata, a vector DB for embeddings, Elasticsearch for full-text, and hundreds of lines of glue code to fuse multi-source retrieval—you're paying the "stitching tax." Industry surveys suggest that a large share of production AI applications still run on multiple databases—relational, vector, and full-text in separate systems—because of data diversity and legacy architecture. That pattern remains common even in large enterprises. This article is about why we built seekdb, and what you actually get when you stop stitching.

1. The Stitching Tax Is Real

RAG, semantic search, and agents all need the same kinds of data: who, what, where (relational), what was said or written (full-text), and what it means semantically (vectors). In practice, that means MySQL/PostgreSQL for business data, Milvus/Pinecone/Qdrant for vectors, Elasticsearch for full-text, and a thick layer of application code: multi-path queries, normalization, score fusion, reranking.

The result is obvious: three systems, two sync pipelines, and a pile of glue code. The business DB updates today; the vector store might still be yesterday's. You run three backup strategies, three monitoring stacks, three upgrade cycles. Every feature change can touch "DB A + DB B + app logic." This isn't a technology choice problem—it's architecture tax. Every new AI capability adds another layer.

So we have a simple stance: AI apps shouldn't start by stitching databases. If one engine can handle relational, vector, full-text, and JSON, use one. If one query can express "vector similarity + keywords + filters," don't assemble it in the app. We're not saying distributed or multi-cluster is useless—we're saying that for most teams, getting "no stitching" right matters more than stacking more systems.

2. One Engine Instead of Three

seekdb is an open-source, AI-native hybrid search database, under Apache 2.0—commercial use, modification, distribution, and forking are all allowed. No vendor lock-in. Code and design live on GitHub; you can audit it, change it, and deploy it yourself. In one sentence: relational, vector, full-text, JSON, and GIS live in one store, one transaction model, one write path—scalar and vector indexes update together. No bugs where the business DB is updated but the vector DB hasn't caught up.

You can:

Run one SQL statement for vector similarity, full-text match, and relational filters—no querying three systems and merging in memory;
Run embedding, reranking, and LLM inference inside the database, so RAG's "retrieve → rerank → generate" has fewer hops and simpler ops;
Deploy as embedded (a single import in Python), single-node server, or client/server; 1C2G is enough, and it plays well with existing MySQL tooling.

The audience is clear: teams tired of "multi-DB + glue," and people building RAG from scratch who don't want to stitch three systems on day one. You want one database, one query interface, one ops stack. seekdb is built for that.

3. The Bottleneck Isn't Scale—It's Fragmentation

For a huge slice of AI use cases, the bottleneck isn't "data won't fit on one machine"—it's too many systems, too many interfaces, too slow to iterate. We tackled that first: one process, one API, one SQL for hybrid search and in-database AI. When you truly need cross-DC or petabyte scale, you can add distribution then. Many teams never get there; they're already slowed down by stitching.

So seekdb's "from complex to simple" isn't about removing features—it's moving "multi-system + glue" into a single engine. The complexity is still there; it's just inside the database instead of in your code and runbooks.

4. What You Stop Paying

What you stop paying for	Stitched setup	seekdb
Freshness	Business DB updates → async sync to vector/full-text → delay and consistency windows	Single transaction; write once, index once. No sync lag.
Glue code	Multi-path queries, normalization, fusion, rerank—all in the app	One SQL for the full hybrid intent; rerank/LLM can live in-database
Ops	Multiple backup, monitoring, upgrade, and capacity plans	One database, one ops stack
Learning curve	Three APIs, three query languages	MySQL protocol + SQL; one `import` for embedded

We're not saying stitching is always wrong—at large scale with strong teams, a multi-system setup can work. But for teams that want to ship fast, want consistency, and want fewer footguns, "no stitching" is often the better first step.

5. Stop Stitching, Start Building

Stop stitching, start building. We built seekdb and made it fully open source to give teams that don't want to start from "stitching the databases" an auditable, modifiable, self-hostable option: one engine, one SQL, one ops stack. Get RAG and semantic search running first; scale later. Open source means: the docs and code are the full picture—no black box. Hit an issue? Open an issue, join the discussion, or send a PR. We iterate with the community.

Repo: github.com/oceanbase/seekdb (Apache 2.0 — Stars, Issues, PRs welcome)
Docs: seekdb documentation
Discord: https://discord.com/channels/1331061822945624085/1331061823465590805
Press: OceanBase Releases seekdb (MarkTechPost)

We would also love to hear your stories, insights, and perspectives on the future of AI and databases. Open source is more than a development model — it’s a mindset. That’s why we choose to build openly, together with the community.

Because we truly believe: Great things start when people talk, share, and create freely.

And that’s where the magic begins.

From Zero To seekdb · Article 1