How to Use the Marqo AI (Vector Search & Embeddings) MCP in LangChain

Q: Can my LangChain agent choose which Marqo index to query?

Yes. Instruct your agent to first call listindexes to see available options. Based on the user's query or other context, the agent can then select the most appropriate index name to use in its tensorsearch call.

Q: What's the difference between this and just calling the Marqo API directly?

This server lets your AI agent decide when and how to call Marqo's tools as part of a larger goal. Instead of you writing a rigid script, the agent dynamically composes operations like createindex and tensorsearch based on the situation.

Build self-correcting search agents with LangChain that manage Marqo indexes and run tensor queries automatically.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Marqo AI (Vector Search & Embeddings) MCP to LangChain

Create your Vinkius account to connect Marqo AI (Vector Search & Embeddings) to LangChain and route execution through our secure gateway. The platform manages server hosting, runtime updates, and security layers. Configuration requires no manual server provisioning.

GDPR Free for Subscribers

Setup Marqo AI (Vector Search & Embeddings) with LangChain

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Build multi-step indexing pipelines

Chain together Marqo operations to create autonomous indexing workflows. Your LangChain agent can first call `create_index` to set up a new vector space with specific model properties. Then, it can loop through your data source and feed it into the index using `add_documents`. This isn't just a script; it's a reasoning process. The agent decides the sequence. If index creation fails, it can retry or report back. You define the goal, and the agent figures out the steps to get your documents ready for search.

Run dynamic, context-aware searches

Let your agent handle the search queries. It can take a user's natural language question, pass it directly to `tensor_search`, and return the results. The agent isn't just a dumb pipe; it can use other tools to enrich the query or decide which index to target. Before running a query, your agent can use `get_index_stats` to check if an index has enough documents to be worth searching. This simple check, executed as part of a chain, prevents wasted queries and improves the quality of the final answer. This MCP Server makes your agent smarter about how it searches.

Make Marqo observable with LangChain

Every tool call your agent makes is traced and logged. When your agent uses `delete_documents`, you can see the exact document IDs it targeted in your LangSmith dashboard. This gives you a clear audit trail for every change made to your indexes. Debugging complex chains becomes simple. You can see the full context for every action — the inputs, the outputs, the latency. You'll know precisely why your agent chose to run a `tensor_search` or check `list_indexes` at any given step.

Setup guide

Set up Marqo AI (Vector Search & Embeddings) MCP in LangChain

Prerequisites

Python 3.10+ installed
langchain-mcp-adapters + langgraph packages
Active Vinkius subscription with a valid endpoint token

1

Install dependencies
Run pip install langchain-mcp-adapters langgraph langchain-openai. The MCP adapters package converts MCP tools into native LangChain BaseTool objects.
2

Connect via HTTP transport
Use MultiServerMCPClient with "transport": "http" pointing to your Vinkius endpoint. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.
3

Create a ReAct agent
Pass the discovered tools to create_react_agent() from LangGraph. The agent automatically routes Marqo AI (Vector Search & Embeddings) tool calls through the MCP protocol.
4

Run with any LLM
Swap ChatOpenAI for ChatAnthropic, ChatGoogleGenerativeAI, or any LangChain-compatible model. The MCP tools work identically across all providers.

agent.py

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

async with MultiServerMCPClient({
    "marqo-ai-vector-search-embeddings-mcp": {
        "transport": "http",
        "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp",
    }
}) as client:
    tools = client.get_tools()

    agent = create_react_agent(
        ChatOpenAI(model="gpt-4o"),
        tools,
    )
    result = await agent.ainvoke({
        "messages": "List recent Marqo AI (Vector Search & Embeddings) transactions"
    })
    print(result["messages"][-1].content)

Get your connection token →

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.

Why Choose Vinkius

Vinkius connects your tools to AI with real-time monitoring and automatic cost savings — all from one dashboard.

Connect Marqo AI (Vector Search & Embeddings) now

Real-time monitoring

Live

visibility into every interaction

Connect your favorite tools to your AI and see exactly what's happening — every request, every response, in real time.

Built-in savings

60%

lower AI costs

Vinkius compresses data between your apps and your AI automatically. Lower bills every month — no configuration required.

Single dashboard

One

place for every integration

Every tool your AI connects to, managed from a single screen. One account, complete control.

Common questions about Marqo AI (Vector Search & Embeddings) MCP in LangChain

First, get the tools from the MCP client and pass them to your agent. In your prompt, instruct the agent to use the `add_documents` tool to index the information, and then use the `tensor_search` tool to find it. The agent will handle the two-step sequence on its own.

Yes. Instruct your agent to first call `list_indexes` to see available options. Based on the user's query or other context, the agent can then select the most appropriate index name to use in its `tensor_search` call.

If you have LangSmith configured, every tool call is automatically traced. You can see the exact payload sent to `add_documents` or the results from `get_index_stats`, which is perfect for debugging your agent's reasoning.

This server lets your AI agent decide *when* and *how* to call Marqo's tools as part of a larger goal. Instead of you writing a rigid script, the agent dynamically composes operations like `create_index` and `tensor_search` based on the situation.

Your agent sends the JSON documents for indexing and the string IDs for deletion. Vinkius processes these operations in an ephemeral, single-tenant sandbox for your requests. The MCP Server itself is stateless and doesn't store your data after the operation is complete.

Use it with your favorite AI tools

Connect this server to Cursor, Claude, VS Code, and more.

OpenAI Agents SDK sdk-python

Google ADK sdk-python

Pydantic AI sdk-python

Vercel AI SDK sdk-typescript