How to Use the EyePop.ai MCP in LangChain

Q: How do I pass local image files to EyePop.ai using LangChain?

Pass the file path to analyzeimage within your LangChain MCP tool call. The agent reads the local file, converts it, and sends it to the visual pipeline, returning bounding boxes to your chain.

Q: Can my LangChain agent dynamically switch models in EyePop.ai?

Yes, your agent calls listmodels to see what is available, then updates the setup. It then uses createpop to configure the correct pipeline before running the analysis.

Q: How does LangChain handle long video processing with EyePop.ai?

The agent triggers analyzevideo and monitors the temporal results. LangSmith tracks the latency and outputs of the tool call, giving you full visibility into the execution time.

Build multi-step visual reasoning chains in LangChain using computer vision pipelines that run on demand.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect EyePop.ai MCP to LangChain

Create your Vinkius account to connect EyePop.ai 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 EyePop.ai with LangChain

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Run real-time media analysis inside LangChain loops

The `analyze_image` tool executes instant object detection and classification inside your active LangChain chains. Your agent sends any image URL or file path straight to the model, parses the raw coordinates, and pipes those bounding boxes directly into the next LangChain run step. If you feed a file into `analyze_video`, your LangChain agent watches the whole timeline, tracking object movements to determine the next action in the sequence. This lets your agent make decisions based on real-time visual events without you writing custom computer vision glue code.

Manage visual pipelines dynamically using this MCP Server

The `create_pop` tool lets your LangChain agent spin up tailored visual pipelines without manual dashboard setup. You tell the agent what you want to detect, and it configures the pipeline parameters, instantly initializing the pipeline for incoming media. Your agent can verify the setup by calling `get_pop` or `list_pops` to ensure everything runs correctly. This makes your visual pipelines completely programmable, shifting the burden of infrastructure management over to your LangChain runtime.

Pre-flight checks keep LangChain executions clean

The `list_models` tool exposes the available computer vision models directly to your LangChain agent's planning phase via this MCP tool. Before sending heavy video files, the agent checks what models exist to ensure it uses the correct detection logic. You don't want your run failing halfway through, so the agent calls `check_eyepop_status` to confirm the API connection is active. This pre-flight check keeps your LangChain production traces clean and saves you money on failed runs.

Setup guide

Set up EyePop.ai 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 EyePop.ai 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({
    "eyepopai-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 EyePop.ai 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 EyePop.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 EyePop.ai 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 EyePop.ai MCP in LangChain

Pass the file path to `analyze_image` within your LangChain MCP tool call. The agent reads the local file, converts it, and sends it to the visual pipeline, returning bounding boxes to your chain.

Yes, your agent calls `list_models` to see what is available, then updates the setup. It then uses `create_pop` to configure the correct pipeline before running the analysis.

The agent triggers `analyze_video` and monitors the temporal results. LangSmith tracks the latency and outputs of the tool call, giving you full visibility into the execution time.

No, Vinkius handles the API keys on its end. Your LangChain agent only needs the single Vinkius endpoint token to run all ten visual tools.

Your raw images and videos go directly to the EyePop.ai endpoint for processing and are not stored by the transport layer. The Vinkius sandbox isolates the execution, keeping your visual data private and ephemeral.

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