Supabase Vector MCP. Run pgvector searches and CRUD ops directly from chat.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Supabase Vector connects your AI client directly to Supabase's PostgreSQL database via MCP. It lets you run pgvector semantic searches, manage embeddings, and perform foundational CRUD operations—all from natural language commands in your terminal.
You don't need an external dashboard or manual SQL writing to query complex vector data.
What your AI agents can do
Call postgres function
Executes a pre-defined, custom Postgres function (RPC) using specific parameters.
Delete table rows
Permanently removes rows from a specified table based on matching one or more column values. Be careful; this action is irreversible.
Get table row
Retrieves the data for a single row by requiring an exact match against a specific column value.
Runs a vector search using the pgvector extension to find records based on contextual similarity rather than keyword matching.
Lists all available tables in your Supabase project so the AI agent knows where it can read data from.
Retrieves a single, specific row of data by matching a known column value within any table.
Inserts multiple new rows into a target table using a structured JSON array input.
Permanently removes one or more rows from a table based on defined column values. This action is irreversible.
Runs pre-built, complex PostgreSQL functions (RPCs) that handle specific business logic beyond simple CRUD operations.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
Supabase Vector: 7 Tools for Database Operations
These tools allow your AI client to execute everything from simple row lookups (`get_table_row`) to complex semantic vector matching (`match_vectors`) against your Supabase database.
019d760fcall postgres function
Executes a pre-defined, custom Postgres function (RPC) using specific parameters.
019d760fdelete table rows
Permanently removes rows from a specified table based on matching one or more column values. Be careful; this action is irreversible.
019d760fget table row
Retrieves the data for a single row by requiring an exact match against a specific column value.
019d760finsert table rows
Adds new records to a specified table using a structured JSON array containing the necessary field values.
019d760flist tables
Returns an inventory of all tables that currently exist within your Supabase project database schema.
019d760fmatch vectors
Performs a vector similarity search by running a Postgres RPC, requiring both an embedding array and a function name.
019d760fquery table rows
Queries one or more rows from a specific table, allowing you to select columns and limit the result set.
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
Make Your AI Do More
Start with Supabase Vector, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ 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
What you can do with this MCP connector
Supabase Vector connects your AI client directly to Supabase's PostgreSQL database through MCP. It lets you run vector searches using pgvector, manage embeddings, and perform core CRUD operations—all from natural language commands in your terminal. You bypass needing an external dashboard or manually writing SQL to query complex vector data.
When you use this server, your AI agent interacts with the database using specific tools. First, if you don't know what tables exist, you can run list_tables and get a complete inventory of every table in your Supabase schema.
To read data, you have two options. You can use get_table_row to pull all information for one specific row when you know the exact value it holds for a defined column. If you need more than one record, or if you want to select only certain columns from multiple results, you'll use query_table_rows, which queries several rows from a specified table.
For advanced searching, you run vector similarity checks using match_vectors. This tool executes a custom Postgres RPC function, taking both an embedding array and the specific function name as parameters to find records based on contextual meaning instead of just keyword matches. You'll also use call_postgres_function when you need to execute complex, pre-built PostgreSQL business logic that goes beyond simple reading or writing.
To modify data, you can insert multiple new rows into a target table using insert_table_rows, which accepts a structured JSON array containing all the necessary field values. When you need to clean up old assignments or remove records entirely, you'll use delete_table_rows to permanently remove one or more rows based on matching column criteria; remember this action is irreversible.
Essentially, your agent treats the database like a set of functions: it runs list_tables for schema inspection, uses query_table_rows and get_table_row for reading data, relies on match_vectors and call_postgres_function for specialized operations, and finally manages data state using insert_table_rows, delete_table_rows, and the foundational database tools.
How Supabase Vector MCP Works
- 1 Set up the Supabase Vector MCP module as an active integration in your CLI environment.
- 2 Bind your deployed
SUPABASE_URLand secureSUPABASE_SERVICE_KEYinto the configuration matrix. - 3 Instruct your agent: 'Match the current context to my X function, extracting the N most similar articles, then call the review RPC.' The agent executes the sequence via tools.
The bottom line is you tell your AI agent what data you need—a vector match, a row delete, or a table list—and it handles the secure connection and execution against Supabase.
Who Is Supabase Vector MCP For?
This is for the data engineer who hates clicking through 15 different dashboards just to run a few queries. It’s for backend developers debugging complex RAG pipelines, or database admins needing to test semantic accuracy directly from the prompt line. You need full control over your vector space without leaving your terminal.
Tests embedding models and distance metrics by rapidly calling match_vectors against different datasets to validate semantic accuracy.
Debugs RAG deployments by running foundational CRUD operations (query_table_rows, insert_table_rows) and inspecting the underlying schema using list_tables.
Diagnoses semantic issues or runs custom logic by calling complex PL/pgSQL algorithms via call_postgres_function directly in conversation.
What Changes When You Connect
- Full Data Control: You don't just read data. Use
insert_table_rowsto add new embeddings or usedelete_table_rowsto clean up old test data, giving you complete control over the dataset structure. - Semantic Search Power: Forget keyword matching. The
match_vectorstool executes deep contextual similarity searches using pgvector, finding related documents even if they don't share keywords. - Schema Introspection: Need to know what tables exist? Run
list_tables. It tells your agent the entire database schema structure before you write a single query. - Custom Business Logic: When simple CRUD isn't enough, use
call_postgres_functionto launch complex PL/pgSQL algorithms that handle specialized business rules. - Targeted Data Retrieval: Use
get_table_rowwhen you know the exact ID or primary key. It retrieves one specific row without running a full table query.
Real-World Use Cases
Debugging RAG Embeddings
A developer needs to test if their new embedding model is performing correctly on old documents. They first use list_tables to confirm the target 'embeddings' table, then run a targeted query with query_table_rows to pull 50 sample vectors for manual review before running a full match_vectors validation.
Clearing Stale Test Data
A DBA finishes a large test and knows the 'test_docs' table is polluted with old embeddings. They run list_tables to confirm the name, then execute delete_table_rows to wipe out all legacy data cleanly.
Processing New Documents
The agent receives a batch of new documents and their calculated embeddings. The developer uses insert_table_rows, providing the JSON array, which populates the vector store immediately for use in future semantic searches.
Running Complex Business Checks
An agent needs to check user eligibility based on multiple data points (status, subscription level). Instead of a simple query, they call call_postgres_function with the necessary parameters; this executes complex, multi-step logic defined in the backend.
The Tradeoffs
Treating everything like a spreadsheet.
Trying to run a join across three different tables using only query_table_rows because it sounds simpler than SQL. This usually fails or returns incomplete data.
→
For complex, multi-table operations that require joins, you must use call_postgres_function. That tool wraps the raw power of SQL and is designed to execute complicated logic across multiple linked data sources.
Over-relying on simple reads.
When you want documents similar in meaning, running a standard query_table_rows with keywords. This only finds exact matches, not contextually relevant ones.
→
For semantic search—finding things that mean the same thing—you must use match_vectors. It requires an embedding array but is built for contextual similarity.
Modifying data without confirmation.
Running delete_table_rows on the wrong table, or forgetting to specify which column links the rows. The action is irreversible and will cause data loss.
→
Always confirm the target table name using list_tables first. When deleting, always double-check your parameters before confirming the final command.
When It Fits, When It Doesn't
Use this MCP Server if your primary pain point is connecting advanced AI logic (like RAG or semantic search) to a live PostgreSQL database without writing boilerplate SQL or using external UIs. It's perfect when you need full control—from simple get_table_row reads up through complex, custom PL/pgSQL execution via call_postgres_function.
Don't use this if all your data is stored in a non-relational format (like pure flat files) or if you only ever need to read static, unchanging public API endpoints. If the source of truth isn't PostgreSQL, this server won't help. When building a system that needs both standard records and vector search capabilities, this combination of tools is necessary.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Supabase Vector. 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
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 server provides 7 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Running queries against your knowledge base shouldn't feel like debugging an SQL textbook.
Today, if you need to find documents similar in *meaning* (semantic similarity), you have to write complex vector search calls or rely on a dedicated external platform. This usually means exporting data, running the model elsewhere, and then re-importing results—a massive headache.
With Supabase Vector MCP, you just tell your agent: 'Match this context against my document embeddings.' The `match_vectors` tool handles the entire process—the embedding comparison, the Postgres RPC call, and returning the top N matches. It keeps everything contained in your terminal.
Supabase Vector MCP Server: Get structured data updates from chat.
Before this server, if you needed to update a user's status or insert new embeddings into production, you had to switch environments—open DBeaver, run the `INSERT` statement, commit, and then check your dashboard. It was multi-step, slow, and prone to human error.
Now, you just tell your agent: 'Insert this JSON array of records into the user table.' The `insert_table_rows` tool handles the insertion atomically right in your chat window. You get real-time confirmation that the data landed.
Common Questions About Supabase Vector MCP
How do I perform a semantic vector search using match_vectors? +
You invoke match_vectors and provide two things: the specific RPC function name and your embedding array. The agent executes this via Postgres RPC, finding contextually similar records instantly.
Is calling_postgres_function safe for my database? +
It's powerful because it allows running any custom PL/pgSQL function, which handles complex logic. Since the tool requires defining and wrapping these functions beforehand, you control the risk by knowing exactly what code is being executed.
What if I need to read only one record? +
Use get_table_row. You specify a table name and must provide a value for a column that uniquely identifies the row you want to retrieve. It’s faster than running a general query.
Can I list all available tables with Supabase Vector? +
Yes, use list_tables. This tool queries your entire project and gives your agent an inventory of every table name it can interact with. It's the first step for any exploration.
Is running `query_table_rows` safe regarding row-level security? +
Yes, your AI client bypasses standard row-level security by using the service_role key. This allows it to operate with administrator permissions on the database structure itself.
What is the risk of using `delete_table_rows`? +
The deletion action is irreversible. You must verify the column value and the target table before running this tool, as any data removed cannot be recovered through the client.
How do I optimize performance when querying with `query_table_rows`? +
To improve speed, always specify the exact columns you need in the select statement and use limit parameters. Don't ask for every single field if you only require two or three.
What format must my data be in when using `insert_table_rows`? +
You must provide a JSON array of row objects. The structure needs to match the column schema of your target table exactly for the tool to execute successfully.
Are embedding arrays processed efficiently during intensive vector similarity matching? +
The integration specifically manages large semantic arrays seamlessly by calling lightweight Postgres RPC configurations locally natively internally securely.
How is risk managed securely when manipulating and clearing root analytical vectors? +
Executing delete_table_rows operates systematically relying inherently on exactly structured string conditions implicitly naturally precisely eliminating ambiguity securely effectively actively strictly smoothly securely precisely correctly reliably locally dynamically successfully effortlessly intelligently gracefully elegantly safely accurately directly comprehensively natively.
Which distance metrics does the vector search support? +
pgvector supports cosine similarity, inner product, and L2 (Euclidean) distance. The metric used depends on how your RPC function and index are configured in PostgreSQL — the AI passes arguments accordingly.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
Datadog
Monitor infrastructure, applications, and logs with unified observability that gives you full-stack visibility in real time.
Tailscale
Manage your Tailscale mesh network — list devices, update ACL policies, manage auth keys, and inspect users directly from any AI agent.
Notion
Unified AI interface for your Notion workspace — search pages, query databases, and manage blocks via AI.
You might also like
Conekta
Equip your AI agent to securely manage Latin American payments, view transactions, and track sales using the Conekta API.
ncScale
Monitor and observe your no-code stack via ncScale — track logs, alerts, and tickets directly from your AI agent.
EIA Natural Gas — Gas Market Intelligence
Natural gas market data: Henry Hub spot and futures prices, underground storage levels (the weekly report that moves markets), LNG imports/exports, production by state, pipeline flows, and consumption by sector.