How to Use the Elasticsearch Vector MCP in LangChain

Q: How do I run an Elasticsearch Vector kNN query inside a LangChain agent?

You use the search tool. Your agent takes the input query, converts it to an embedding, and passes it to the tool to retrieve the 10 closest document matches.

Q: Can LangChain handle index creation dynamically with the Elasticsearch Vector MCP Server?

Yes. The agent uses createindex to set up the mapping for your dense vector fields. It then verifies the setup using getindex before running any indexing tasks.

Q: How does LangChain track the latency of Elasticsearch Vector operations?

LangSmith traces every call to indexdocument or search automatically. You see the exact millisecond cost of every vector operation in your chain execution log.

Q: What happens if my LangChain agent tries to search a non-existent index?

The agent first calls listindexes to verify the target exists. If it doesn't find a match, you can configure your LangChain graph to call createindex before running the search.

Run dense vector kNN searches directly inside your LangChain reasoning loops with this managed MCP server.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Elasticsearch Vector MCP to LangChain

Create your Vinkius account to connect Elasticsearch Vector 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 Elasticsearch Vector with LangChain

Ask AI about this MCP

ChatGPT

Claude

Perplexity

LangChain agents decide when to index or query

The `search` tool pulls relevant vectors and feeds that raw data directly into the next LangChain run. Your agent checks if the target index exists using `get_index` before running any search operations, preventing broken chains. If a document needs updating, the agent calls `index_document` during the run. This happens inside the LangChain execution graph, so you can trace the exact latency of every single vector write in LangSmith.

Dynamic index management in multi-step chains

The `create_index` tool lets your LangChain agent set up a new dense vector index mapping on the fly when starting a new document tracking chain via this MCP integration. You don't have to pre-configure schemas manually before running your pipeline. Once the index is ready, the agent uses `list_indexes` to verify it's active. This lets your chain handle dynamic data partitioning across different Elasticsearch indexes without hardcoded setup steps.

Clean up stale vectors during LangChain runs

The `delete_document` tool removes outdated vector records directly from your LangChain agent's memory-clearing chains. Your agent identifies dead records during its reasoning loop and deletes them instantly to keep the index size small. This keeps your vector search pool fresh. Because LangChain tracks every tool call, you can audit exactly which document was removed and why, right from your observability dashboard.

Setup guide

Set up Elasticsearch Vector 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 Elasticsearch Vector 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({
    "elasticsearch-vector-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 Elasticsearch Vector 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 Elasticsearch 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.

Why Choose Vinkius

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

Connect Elasticsearch Vector 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 Elasticsearch Vector MCP in LangChain

You use the `search` tool. Your agent takes the input query, converts it to an embedding, and passes it to the tool to retrieve the 10 closest document matches.

Yes. The agent uses `create_index` to set up the mapping for your dense vector fields. It then verifies the setup using `get_index` before running any indexing tasks.

LangSmith traces every call to `index_document` or `search` automatically. You see the exact millisecond cost of every vector operation in your chain execution log.

The agent first calls `list_indexes` to verify the target exists. If it doesn't find a match, you can configure your LangChain graph to call `create_index` before running the search.

All vector embeddings and document payloads pass through an isolated V8 sandbox. No raw vector data is stored on Vinkius; it is immediately routed to your Elasticsearch instance using secure, single-use tokens.

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