Echo.lee for seekdb

Posted on Mar 12

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

#ai #mcp #datascience #programming

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