MyScale (SQL Vector Database API) MCP for AI. Combine SQL queries with high-recall vector searches.

Q: How do I check if my MyScale cluster is ready before running queries using pingcluster?

You run pingcluster first. A successful response confirms the connection and credentials are good, meaning your subsequent calls to vectorsearch or executesqlquery should work without authentication errors.

Q: Can I create a new data table using createvectortable?

Yes. You use createvectortable and specify the necessary dimensions (e.g., 1536-dimension float array) in your prompt. The tool handles defining the correct schema constraints.

Q: What's the difference between vectorsearch and executesqlquery?

vectorsearch is designed specifically for semantic similarity lookups, automatically building distance functions (like cosine). executesqlquery runs any arbitrary SQL statement; use this when you need to run maintenance queries or complex joins that aren't vector-related.

Q: After I build a table with createvectortable, when should I run createvectorindex?

You must use createvectorindex before performing searches. This tool builds the necessary data structure on your new vector column, which is required for fast similarity lookups and efficient querying.

Q: Does running a general query using executesqlquery always return JSON format?

Yes, when you run a SELECT query via executesqlquery, the API automatically appends FORMAT JSON to your results. This ensures that all returned data is consistently structured for easy parsing by your agent.

Q: If my vector index fails, how do I diagnose the problem using checkindexstatus?

The checkindexstatus tool reports if the build status is 'Error'. If it shows an error, you'll need to review the cluster logs for specific failure messages and adjust your source data or index definition.

Claude

ChatGPT

Cursor

Gemini

Windsurf

VS Code

JetBrains

Vercel

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Connect to your AI in seconds.

MyScale (SQL Vector Database API) lets you manage complex vector databases using standard SQL syntax. Your AI agent runs everything—from simple data lookups (`execute_sql_query`) to high-recall semantic searches (`vector_search`), and managing the underlying indices (HNSW, ScaNN)—all in one chat session.

It makes running RAG pipelines feel like just another query.

What your AI can do

Check index status

Checks the build status of a vector index (Built, InProgress, or Error).

Create vector index

Adds a specialized performance index to an existing table.

Create vector table

Creates a brand new database table that supports vector data types.

+ 3 more capabilities included

Run arbitrary SQL queries

Execute any standard database query (SELECT, INSERT, ALTER) on the connected MyScale cluster.

Perform vector similarity searches

Find content most similar to a given data point by automatically constructing and running complex SQL queries.

Create new tables with vectors

Define an entirely new table structure, including adding the necessary vector column and metadata constraints.

Build specialized vector indexes

Add performance indices (like HNSW) to existing tables, optimizing search speed for large datasets.

Monitor index build status

Check the operational state of any vector index to confirm if it is Built, InProgress, or in an Error state.

Validate cluster connectivity

Confirm that your provided credentials and the MyScale cluster are fully reachable and active.

Ask an AI about this

Included with Plan

Waiting for input…

AI Agent

MyScale (SQL Vector Database API): 6 Tools for Data Access

These tools give your AI client direct access to the underlying MyScale database layer, letting it manage everything from index creation to complex vector lookups.

Make your AI actually useful.

Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.

Start using MyScale (SQL Vector Database API) on Vinkius

Check Index Status

Checks the build status of a vector index (Built, InProgress, or Error).

Create Vector Index

Adds a specialized performance index to an existing table.

Create Vector Table

Creates a brand new database table that supports vector data types.

Execute Sql Query

Runs any custom SQL query against the MyScale cluster, automatically formatting...

Ping Cluster

Verifies that the entire MyScale database cluster is reachable and accepting...

Vector Search

Performs a semantic similarity search using a given vector embedding.

Security and governance baked right in.

Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.

Claude AI

Open Claude Settings

Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.

Add Custom Connector

Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:

https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp

Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. For OAuth-protected servers, expand Advanced settings to add credentials.

Start a conversation

Open a new chat. The MyScale (SQL Vector Database API) integration is available immediately — no restart needed.

Antigravity

Configure Agent Environment

Open your Antigravity agent's workspace configuration or mcp-servers.json file.

Bind the Endpoint

Add the Vinkius endpoint URL to your agent's MCP connections list:

"mcp_servers": {
  "myscale-sql-vector-database-api": {
    "serverUrl": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
  }
}

Provide your secure token in place of [YOUR_TOKEN_HERE] to ensure your agent requests are authenticated.

Execute

Start your Antigravity session. The agent will autonomously discover and utilize the MyScale (SQL Vector Database API) tools with full Vinkius guardrails applied.

VS Code Copilot

⚡

One-Click Install (Recommended)

In your Vinkius Dashboard, simply click the Add to VS Code button for this server. We'll automatically configure your local workspace.

Or configure manually

Open MCP Settings

Open VS Code, press Ctrl/Cmd + Shift + P, and search for GitHub Copilot: MCP Servers.

Add Server Config

Add the Vinkius endpoint configuration to your mcp-servers.json file:

"myscale-sql-vector-database-api": {
  "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
}

Ensure you replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.

LangChain

Install Dependencies

Install the LangChain MCP adapters for your environment:

pip install langchain-mcp-adapters

Connect the Server

Use the SSEClient in LangChain to connect to the Vinkius managed endpoint:

from langchain_mcp_adapters.client import SSEClient

# Connect to Vinkius
client = SSEClient(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")
tools = client.get_tools()

CrewAI

Define the Tool

Load the Vinkius MCP tools into your CrewAI agents:

from crewai import Agent
from mcp_crewai import MCPTool

# Connect securely to Vinkius
vinkius_tools = MCPTool(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")

# Assign to Agent
researcher = Agent(
    role='Data Researcher',
    tools=vinkius_tools.get_all()
)

Execute Task

Run your CrewAI process. The agent will autonomously route tasks to the Vinkius managed server.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

Import from OpenAPI, Swagger, or YAML specs
Create Agent Skills with progressive disclosure
Deploy to edge with MCPFusion framework
Built in DLP, auth, and compliance on every call
Real time usage dashboard and cost metering
Publish to catalog or keep private

Start building

Make Your AI Do More

Start with MyScale (SQL Vector Database API), then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.

Use this MCP plus 5,100+ others, all in one place
Add new capabilities to your AI anytime you want
Every connection is secured and compliant automatically
Track usage and costs across all your servers
Works with Claude, ChatGPT, Cursor, and more
New servers added to the catalog every week

MyScale (SQL Vector Database API) MCP server cover

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by MyScale. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

Your data is protected. See how we built it.

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This connection provides 6 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.

Database queries shouldn't force you to juggle three different tools.

Today, if you need to find the best answer, you usually have to run the search (Tool A) to get a list of IDs. Then, take those IDs and feed them into a separate SQL lookup tool (Tool B) just to grab the metadata needed for context. You spend time writing Python glue code that stitches Tool A's output into Tool B's input.

With MyScale, your agent handles this stitching automatically. Give it one prompt: 'Find relevant results about X and give me their product name.' The system runs `vector_search` and then uses the resulting data to filter or enrich with structured metadata via a single tool call. You get the final answer without touching Python.

MyScale (SQL Vector Database API) MCP Server: Run complex queries from chat.

The biggest manual step that goes away is writing and managing the JOIN logic between a vector search result set and a standard relational table. You used to write this join, execute it, parse the ID lists, and then run cleanup scripts—all before you could even get an answer.

Now, you describe the desired outcome in plain English, and the server executes the necessary combination of `vector_search` and `execute_sql_query`. It's a complete backend stack available to your agent through one API.

Support 24/7 support@vinkius.com ↗

Security Vinkius Trust Center ↗

SLA Service Level Agreement ↗

Report Listing Send Report ↗

What your AI can actually do with this

You gotta manage high-performance vector databases, but you don't wanna write some arcane API calls just to run a query. MyScale lets your AI agent handle complex vector data using standard SQL syntax. Think of it like this: you talk to your agent how you always have—with SQL—and it handles the deep database magic under the hood.

First, you gotta make sure everything's talking. You start by pinging the cluster with ping_cluster. That confirms your credentials are good and that the whole MyScale system is actually up and ready to take connections. Once that green light pops up, you’re cleared for action.

When it comes to querying data, it's straightforward. If you need to run any custom SQL—whether it's a simple SELECT, an INSERT statement, or even an ALTER command—you just call execute_sql_query. The thing here is that no matter what query you throw at it, the results come back formatted as clean JSON.

It makes parsing those data sets a breeze for your agent.

But standard queries aren't enough when you're dealing with meaning. You need semantic search. That’s where vector_search comes in play. You feed it a vector embedding, and the tool automatically builds and runs complex SQL to find content that's semantically similar to what you're looking for. It does all the distance calculation stuff so you don't have to.

If your data structure is missing something, you can build it out. You use create_vector_table when you need a brand new database table set up specifically to handle vector types and metadata constraints. This function lets you define that entire schema—the vector column and all the supporting info—straight from your prompt.

When you've got data in place, you gotta optimize it for speed. You can add specialized performance indexes using create_vector_index. You tell it to build an index like HNSW or ScaNN on an existing table, which dramatically speeds up how fast the database searches huge amounts of data. If you run that and need to know if it's done yet, you check its status with check_index_status.

This tells you instantly whether the index is 'Built,' still 'InProgress,' or if something went wrong ('Error').

So, you validate connectivity first; then, you build your tables and indexes; next, you run queries using plain SQL or perform deep similarity searches. The whole process—from basic data lookup to complex vector indexing—runs through the same familiar SQL syntax your agent knows. You never have to leave the chat window to manage your entire RAG pipeline.

Built · Hosted · Managed by Vinkius MyScale (SQL Vector Database API) - Query Vectors & Indices

Server ID 019e5d39-4671-71eb-9727-d0fe263b4692

Vinkius Inspector

Compliance Grade F

Score 43.65/100

Report View Report ↗

Here's how it actually works

The bottom line is you get database control—indexing, querying, and searching—without writing SQL or embedding code yourself.

Subscribe to this server and provide your specific MyScale Cluster URL, Username, and Password.

Start by running ping_cluster or check_index_status. This confirms the connection is live and ready for work.

Use a single prompt (e.g., 'Find articles about AI governance related to vector [0.12...]') which triggers the agent to run vector_search and returns structured results.

Who is this actually for?

This setup is for the AI engineer who's tired of building brittle data pipelines. It targets anyone running Retrieval-Augmented Generation (RAG) systems that need to query both structured records and unstructured vector embeddings simultaneously. You're here if you treat your database as a source, not just a backend.

Data Scientist

Manages the RAG backend by using create_vector_table for new data sources and running targeted vector_search calls to test retrieval parameters.

AI Engineer

Tests database connectivity and index health by calling ping_cluster or check_index_status, making sure the underlying infrastructure supports the LLM application layer.

Backend Developer

Performs schema maintenance using execute_sql_query to update tables, add constraints, and perform general database cleanup tasks.

What Changes When You Connect

Unified Querying: You don't need separate tools for structured data and embeddings. Use vector_search or execute_sql_query to combine both in one prompt, eliminating context switching between services.

Zero Setup Time: Forget writing boilerplate code to manage indexes. Calling create_vector_index lets your agent build complex structures like HNSW on demand, making the backend appear simple.

Full Schema Control: When you need a new source of truth, create_vector_table handles defining dimensions and constraints automatically. You just describe what's needed in natural language.

Operational Safety: Running ping_cluster or check_index_status upfront means your agent confirms the database is healthy before running costly searches, saving compute time.

Advanced RAG Pipelines: This setup lets you move beyond simple document lookup. You can use execute_sql_query to filter results by user ID or date, then pass that filtered list to a subsequent vector_search for better context.

See it in action

01 01

Building a Product Knowledge Base

A data scientist wants to query product specs (structured) and user manuals (unstructured). Instead of running two services, they ask their agent: 'Find the top 3 matching documents for vector [0.12...] in the 'manuals' table, but only show results where the 'product_id' column from the main 'products' table is 'XYZ'.'. The agent executes vector_search and then uses the resulting IDs to filter with a structured query via execute_sql_query, giving them one unified answer.

02 02

Debugging Index Performance

A backend developer suspects slow search times. They run check_index_status on the 'articles' table and see the HNSW index is marked 'Error'. They immediately use create_vector_index to rebuild it, then re-run their complex query with vector_search, confirming the fix.

03 03

Onboarding New Data Sources

An AI engineer gets a new dataset (e.g., internal HR policies). They first use create_vector_table to define the structure and dimensions, then use execute_sql_query to load initial metadata records, all before running their first live vector search.

04 04

Verifying Connection Before Deployment

A team lead needs to ensure the staging database is ready for testing. They start by calling ping_cluster. If it succeeds, they proceed directly to using vector_search because they know the connection layer won't fail.

The honest tradeoffs

Manual query stitching

Anti-pattern

Running a vector search via one service (getting IDs), then taking those IDs and manually writing a second SQL query for metadata lookup in a separate terminal window.

The Fix

Don't stitch it together. Let your agent run the complex logic end-to-end. Use vector_search first, but frame your prompt to include the necessary structured filters so the tool runs both concepts simultaneously.

Assuming index readiness

Anti-pattern

Starting a long query using vector_search and having it fail midway because the required HNSW index is still 'InProgress' or hasn't been created.

The Fix

Always start by checking status. Run check_index_status. If the status isn't 'Built', use create_vector_index first. This prevents runtime failures.

Overloading the agent with raw SQL

Anti-pattern

Writing a massive, multi-part query in natural language that mixes complex joins and vector functions without clear boundaries.

The Fix

Use execute_sql_query only for simple data retrieval or maintenance. For combined search needs, stick to the specific tools like vector_search, which handles the SQL construction internally.

When It Fits, When It Doesn't

Use this MCP Server if your core problem requires combining structured record lookups (e.g., 'Show me results for Product ID 123') with unstructured semantic similarity searches (e.g., 'What documents discuss Topic X?'). The API is built to minimize the gap between SQL data and vector embeddings.

Don't use it if your need is purely graph traversal (you'll want a specialized Graph Database client) or if your workflow requires real-time, high-frequency streaming updates that bypass batch processing. If you only need simple SELECT statements, execute_sql_query works fine, but you miss the vector search power.

The key difference is this: This tool set handles the logic of combining these two data types into a single agent call; it's not just a database connector—it’s an intelligent query layer.

Questions you might have

How do I check if my MyScale cluster is ready before running queries using ping_cluster? +

You run ping_cluster first. A successful response confirms the connection and credentials are good, meaning your subsequent calls to vector_search or execute_sql_query should work without authentication errors.

Can I create a new data table using create_vector_table? +

Yes. You use create_vector_table and specify the necessary dimensions (e.g., 1536-dimension float array) in your prompt. The tool handles defining the correct schema constraints.

What's the difference between vector_search and execute_sql_query? +

vector_search is designed specifically for semantic similarity lookups, automatically building distance functions (like cosine). execute_sql_query runs any arbitrary SQL statement; use this when you need to run maintenance queries or complex joins that aren't vector-related.

Do I have to worry about index performance after running a query? How does check_index_status help? +

If your search is slow, the first thing to check is the index. Use check_index_status to see if an index needs building or fixing. If it's not 'Built', you need to run create_vector_index.

After I build a table with `create_vector_table`, when should I run `create_vector_index`? +

You must use create_vector_index before performing searches. This tool builds the necessary data structure on your new vector column, which is required for fast similarity lookups and efficient querying.

Does running a general query using `execute_sql_query` always return JSON format? +

Yes, when you run a SELECT query via execute_sql_query, the API automatically appends FORMAT JSON to your results. This ensures that all returned data is consistently structured for easy parsing by your agent.

If my vector index fails, how do I diagnose the problem using `check_index_status`? +

The check_index_status tool reports if the build status is 'Error'. If it shows an error, you'll need to review the cluster logs for specific failure messages and adjust your source data or index definition.

When I use `create_vector_table`, what do I specify regarding dimensions? +

You must define the dimension size when creating a vector table. This process sets up a float array constraint, ensuring that every row you insert has the exact required number of dimensions for your embedding data.

How can I check if my vector index has finished building? +

Use the check_index_status tool. It queries the system tables to show you the current status (Built, InProgress, or Error) for all vector indices in your cluster.

Can I perform a vector search with metadata filtering? +

Yes! The vector_search tool includes an optional filter parameter where you can provide a SQL WHERE clause (e.g., "category = 'science'") to restrict your search results.

What SQL commands are supported by the execute tool? +

The execute_sql_query tool supports standard MyScale/ClickHouse SQL, including SELECT, CREATE, ALTER, and INSERT. For SELECT queries, it automatically formats the output as JSON for the agent.

Connect to your AI in seconds.

Check index status

Create vector index

Create vector table

MyScale (SQL Vector Database API): 6 Tools for Data Access

Make your AI actually useful.

Check Index Status

Create Vector Index

Create Vector Table

Execute Sql Query

Ping Cluster

Vector Search

Security and governance baked right in.

Claude AI

Open Claude Settings

Add Custom Connector

Start a conversation

Claude Code

Open your terminal

Add the MCP Server

Start coding

Cursor

One-Click Install (Recommended)

Open Cursor Settings

Add New Server

Use in Composer

Antigravity

Configure Agent Environment

Bind the Endpoint

Execute

VS Code Copilot

One-Click Install (Recommended)

Open MCP Settings

Add Server Config

Windsurf

One-Click Install (Recommended)

Open Windsurf Settings

Add Server Endpoint

LangChain

Install Dependencies

Connect the Server

CrewAI

Define the Tool

Execute Task

Choose How to Get Started

Build Your Own

Make Your AI Do More

Works with Claude, ChatGPT, Cursor, and more

Database queries shouldn't force you to juggle three different tools.

MyScale (SQL Vector Database API) MCP Server: Run complex queries from chat.

What your AI can actually do with this

Here's how it actually works

Who is this actually for?

What Changes When You Connect

See it in action

Building a Product Knowledge Base

Debugging Index Performance

Onboarding New Data Sources

Verifying Connection Before Deployment

The honest tradeoffs

Manual query stitching

Assuming index readiness

Overloading the agent with raw SQL

When It Fits, When It Doesn't

Questions you might have