4,500+ servers built on MCP Fusion
Vinkius

Marqo AI (Vector Search MCP Server) MCP. Manage your entire vector knowledge base via chat.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Marqo AI (Vector Search & Embeddings) MCP on Cursor AI Code Editor MCP Client Marqo AI (Vector Search & Embeddings) MCP on Claude Desktop App MCP Integration Marqo AI (Vector Search & Embeddings) MCP on OpenAI Agents SDK MCP Compatible Marqo AI (Vector Search & Embeddings) MCP on Visual Studio Code MCP Extension Client Marqo AI (Vector Search & Embeddings) MCP on GitHub Copilot AI Agent MCP Integration Marqo AI (Vector Search & Embeddings) MCP on Google Gemini AI MCP Integration Marqo AI (Vector Search & Embeddings) MCP on Lovable AI Development MCP Client Marqo AI (Vector Search & Embeddings) MCP on Mistral AI Agents MCP Compatible Marqo AI (Vector Search & Embeddings) MCP on Amazon AWS Bedrock MCP Support

Just plug in your AI agents and start using Vinkius.

Marqo AI handles semantic search and vector indexing for your data. It lets your agent execute complex tensor queries, build new indices from scratch, or ingest raw JSON documents without writing boilerplate API code.

You manage your entire knowledge base—from creation to query—all through natural conversation.

What your AI agents can do

Add documents

Writes new documents, structured as JSON, into a specified Marqo vector index.

Create index

Builds an explicitly bounded, new vector index with custom settings and constraints.

Delete documents

Removes specific documents from Marqo by targeting them using their unique IDs.

+ 3 more capabilities included
Perform Semantic Searches

Run natural language queries to find documents based on meaning, not just keywords.

Manage Index Structure

Create and configure new vector indices with specific model settings and dimension limits.

Ingest New Data

Write structured JSON records into an existing index, making the data immediately available for search.

Audit Index Health

Get detailed statistics on any index, including document count and embedding model details.

Clean Up Data

Delete specific documents from an index using their unique IDs to maintain data relevance.

Inventory Collections

List all available vector indices on the Marqo instance so you know exactly what's there before querying.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

Marqo AI (Vector Search) MCP Server: 6 Tools for Indexing

These six tools let you control the full lifecycle of vector embeddings: listing indexes, creating them, adding data, deleting it, and running semantic searches.

add019d75cf

add documents

Writes new documents, structured as JSON, into a specified Marqo vector index.

create019d75cf

create index

Builds an explicitly bounded, new vector index with custom settings and constraints.

delete019d75cf

delete documents

Removes specific documents from Marqo by targeting them using their unique IDs.

get019d75cf

get index stats

Retrieves the configuration and operational statistics for a given vector index.

list019d75cf

list indexes

Lists all existing Marqo vector indexes, helping you understand your current data boundaries.

tensor019d75cf

tensor search

Executes natural language queries against an index to find semantically related documents.

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 Marqo AI (Vector Search & Embeddings), 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

You're running an AI client—Claude, Cursor, whatever—and you need it talking to your internal data. This server lets your agent handle complex vector search and indexing for your knowledge base without you having to write any boilerplate API code. You manage everything from creating the index structure all the way through querying documents, just by talking to it.

The tensor_search tool runs natural language queries against a specified vector index. When you use this, your agent doesn't look for keywords; it finds meaning. It executes dense semantic similarity searches, so if you ask something conceptually related to a document but don't use the exact words, the system pulls up the right stuff.

This means your AI client can answer questions based on context, not just matching text blocks.

When you need to build or update your data source, you've got create_index. You use this to build an explicitly bounded vector index from scratch. It lets you set custom model settings and dimension constraints right out of the gate, giving you fine-grained control over your search architecture before a single document gets loaded.

Think of it like laying down the perfect foundation for your data warehouse.

Once the container is built, you fill it using add_documents. This tool takes structured JSON records and writes them directly into that existing Marqo vector index. The moment those documents are added, they're immediately available for semantic searching by your agent. You can keep feeding fresh information to your knowledge base through conversation.

To make sure your data stays tight, you use delete_documents. This tool lets you remove specific records from an index by targeting them with their unique IDs. If a document gets outdated or is no longer relevant, you don't have to re-index the whole thing; you just delete it precisely.

Keeping track of what you've got is critical. The list_indexes tool shows every single vector index that currently exists on your Marqo instance. You run this when you want a full map—a quick inventory—of all your data collections before you try to query anything. It lets you know exactly what boundaries you're working within.

When you need an operational checkup, get_index_stats pulls detailed configuration metrics for any given index. You can see the document count, what embedding model it used, and its overall schema mapping. This is how you audit the health of your data source without having to manually count things or dive into a dashboard.

Essentially, you use this server so your agent talks directly to Marqo's core functionality: you define the index structure with create_index, populate it with fresh JSON using add_documents, run meaning-based searches with tensor_search, and then maintain that data—getting stats with get_index_stats, deleting garbage with delete_documents, and keeping tabs on everything with list_indexes.

How Marqo AI (Vector Search MCP Server) MCP Works

  1. 1 First, provide your agent with the specific Marqo API URL and API Key.
  2. 2 Next, use list_indexes to verify which collections exist in your environment. This prevents accidental queries against the wrong data set.
  3. 3 Finally, run a query using tensor_search or add new data via add_documents. The agent handles all the vector conversion and retrieval steps.

The bottom line is you control the entire document lifecycle—from initial index setup to final search result cleanup—without writing API code.

Who Is Marqo AI (Vector Search MCP Server) MCP For?

Search Architects, ML Engineers, and Software Developers. This tool set solves the pain of manual vector database management. If you spend time calling APIs just to check a document count or list available indices before running a query, this is for you.

Machine Learning Engineer

Monitors index metrics using get_index_stats and verifies embedding results directly from the workspace. They use it to confirm data quality after ingestion.

Search Architect

Designs and provisions new vector indices with custom constraints using create_index. They test semantic relevance by running targeted searches via tensor_search.

Software Developer

Integrates AI-powered search results into applications. They manage document lifecycles by calling add_documents and delete_documents programmatically.

What Changes When You Connect

  • Deep Semantic Queries: Use tensor_search to ask questions like, 'What are the best mountain bikes for wet conditions?' and get results based on meaning, not just keywords. This is far better than standard keyword search.
  • Index Lifecycle Control: Never run a query against an index that doesn't exist or isn't configured right. Use list_indexes to map all resources first, then use create_index for clean setup.
  • Instant Data Ingestion: Write new documents directly using add_documents. The data gets vectorized and is available for search immediately—no manual pipeline trigger needed.
  • Data Hygiene: When a document is retired or updated, don't just ignore it. Use delete_documents with specific IDs to guarantee the index remains relevant and clean.
  • Operational Visibility: Before making any changes, use get_index_stats. This gives you hard numbers—like the total document count and embedding model type—so you know exactly what state your data is in.

Real-World Use Cases

01

E-commerce Product Discovery

A user searches for 'shoes good for running on dirt trails.' Instead of getting results that only match the word 'running,' tensor_search finds specialized mountain gear because it understands the intent (trail running). The agent handles the vector query automatically.

02

Updating Technical Documentation

A developer writes a new API guide: 'Use Marqo-API-Key header.' They use add_documents to push this new JSON record into the 'support-docs' index. The moment it’s added, the team can search for that specific instruction using their agent.

03

Auditing Knowledge Base Health

A Data Scientist needs to know how many records are in the 'user-profiles' index and what embedding model was used. They run get_index_stats first, confirming the document count is 15,000 before starting a large batch update.

04

System Cleanup

A search architect realizes an old product line index ('vintage-models') is empty and needs to be decommissioned. They use list_indexes to confirm its name, then manually call the tools to clean up or archive it.

The Tradeoffs

Searching without checking first

Trying to run a query for 'best hiking boots' when you forgot to add documents about them. The search fails, and the user doesn't know why.

Always check your resources first. Run list_indexes to verify the collection name, then use get_index_stats on that specific index before running a query with tensor_search.

Adding data without indexing

Pasting raw JSON into the server and expecting it to be searchable. It just sits there; Marqo needs proper vectorization.

Use add_documents. This tool handles both writing the JSON and triggering the required embedding process, making the data ready for search.

Over-relying on manual API calls

Writing a multi-step script that manually checks stats, lists indexes, then runs search. This is brittle and hard to debug.

Let your agent orchestrate it. The conversation flow allows you to issue commands like 'List all indices, check the stats for the products index, then run a tensor search on product X.' It ties everything together.

When It Fits, When It Doesn't

Use this MCP Server if your primary need is semantic retrieval and managing a document lifecycle. Specifically, you need to convert unstructured text into searchable vectors—that's its job.

Don't use it if all you need is simple keyword matching or filtering by fixed metadata (like 'Product Category = Shoes'). For that, a traditional database search tool will be faster and simpler. If your data doesn't need deep contextual understanding ('Why might this article be relevant?'), don't bother with vector embeddings.

The moment the question becomes 'What does this document mean?' or 'Find me things like this,' you need Marqo AI.

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Marqo AI. 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

How we secure 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 server provides 6 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.

Available Capabilities

add_documents create_index delete_documents get_index_stats list_indexes tensor_search

The Manual Pain of Vector Search Setup

Today, setting up a searchable knowledge base means jumping through hoops. You're in the data warehouse UI, manually defining schemas. Then, you move to your API playground and run boilerplate code just to list existing indexes—a boring step that needs doing every time you start a session. If you forget this step or misspell an index name, your whole query fails.

With this MCP server, the agent handles it all in conversation. You don't write boilerplate code; you simply ask: 'What indices do we have?' The agent runs `list_indexes` and gives you a clean list back. It turns complex infrastructure checks into simple chat commands.

Marqo AI (Vector Search & Embeddings) MCP Server

Before, updating your data meant separate steps: first, manually calling an endpoint to check the index count; second, running a complex script to process and upload new JSON records; third, waiting for the embedding model to finish its job. It was slow, error-prone, and required multiple credentials.

Now, you tell your agent what needs doing—'Add this document about API Auth to support-docs.' The agent runs `add_documents`, manages the entire vectorization process using your configured model, and confirms it’s ready for search. It’s one simple command.

Common Questions About Marqo AI (Vector Search MCP Server) MCP

How do I check if my indices are still healthy with Marqo AI (Vector Search & Embeddings) MCP Server? +

Run the get_index_stats tool. This gives you hard numbers on document counts, embedding model types, and schema mappings. It's your quick way to audit index health.

What is the difference between `list_indexes` and checking stats? +

list_indexes just tells you what indexes exist on the server (the names). get_index_stats requires a specific index name and then gives you metrics about its contents and configuration.

Can I delete documents using `delete_documents`? What IDs do I need? +

Yes, this tool physically removes documents. You must provide the unique scalar identifiers (IDs) for each document you want to erase. It won't guess; it needs exact matches.

What happens if I run `tensor_search` on an index that doesn't exist? +

The search will fail or throw an error because the target resource is undefined. Always use list_indexes first to confirm your collection name before running any query.

What should I do if running `list_indexes` fails due to connection issues? +

First, check your API URL and credentials. A failure usually means the agent can't reach Marqo or lacks proper authentication. Double-check that the provided key has read access permissions for index metadata.

Does the `add_documents` tool require a specific JSON schema when writing new records? +

Yes, you must provide structured data matching your target index's expected fields. If the input JSON deviates from the required schema (e.g., missing 'title'), Marqo will reject the document and report the validation error.

How does running `create_index` impact my search architecture constraints? +

When you call create_index, you explicitly set dimension limits and model types. These settings are permanent for that index, so make sure the new bounds match your use case before proceeding.

Can I refine a natural language query in `tensor_search` beyond just typing text? +

You can combine tensor_search with metadata filters. Instead of relying only on semantic meaning, tell the agent to restrict results by specific fields (like 'product category' or 'date range') for tighter context.

Does Marqo handle the vector embeddings for me through the agent? +

Yes. Marqo is an end-to-end engine. When you use the tensor_search tool, you provide natural language and Marqo handles the model inference and vector extraction under the hood, returning semantically relevant results immediately.

Can I add new data to a vector index through a conversation? +

Absolutely. Use the add_documents tool by providing a JSON array of your documents. Your agent will synchronize these records into the target index, and they will be searchable via semantic query instantly.

How do I check the stats of my vector index? +

The get_index_stats tool retrieves critical metrics for a specific index. Your agent will report the document count, memory usage, and configuration details, helping you monitor the health of your vector store.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 6 tools

We've already built the connector for Marqo AI (Vector Search MCP Server). Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 6 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.