How to Use the CoreMedia Content Cloud MCP in LangChain

Q: How do I pass CoreMedia Content Cloud tools to a LangChain agent?

Install langchain-mcp-adapters, set up the MultiServerMCPClient with your Vinkius endpoint, and call client.gettools(). You can pass these tools directly to your agent constructor, allowing it to run getsitecontext or searchglobalcontent on your CoreMedia setup.

Q: Can LangChain agents chain CoreMedia Content Cloud queries?

Yes. Your agent can run getcmchannelpage to find active layouts, and then immediately feed those layout rules into getcmarticlepath in the next step of the chain. This multi-step reasoning happens entirely within your LangChain execution loop.

Let your LangChain agents fetch CoreMedia Content Cloud layouts and run GraphQL queries to build dynamic, multi-step content chains.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect CoreMedia Content Cloud MCP to LangChain

Create your Vinkius account to connect CoreMedia Content Cloud 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 CoreMedia Content Cloud with LangChain

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Map navigation trees directly inside LangChain chains

Stop hardcoding your navigation logic. This MCP server lets your LangChain agent call `get_navigation_tree` to fetch live CoreMedia Content Cloud menus, feeding the structure straight into the next chain step. You get real-time hierarchy maps without writing custom wrapper APIs. LangSmith records every node extraction, showing you exactly how the agent parses the navigation array before it decides to pull specific pages. It means you can trace layout issues instantly when your agent chains `get_navigation_tree` output into other downstream tools.

Execute GraphQL payloads via this MCP Server

Your LangChain agents can now analyze and query your headless delivery schema dynamically. By exposing `execute_graphql_payload` and `get_introspection_query` to your agent, the model inspects schema limits and runs precise queries based on what the user asks for in real time. You don't have to write GraphQL boilerplate or handle endpoint authentication. The Vinkius-managed MCP server handles the connection, while LangChain manages the tool-calling loop, passing the schema limits directly into your active agent memory.

Track CMArticle property extractions with LangSmith

When your agent needs to fetch deep article metadata, it executes `get_cmarticle_path` to grab properties driving active CMArticle nodes. This tool returns structured content that your LangChain chain can immediately summarize, rewrite, or pipe into other external APIs. Because LangSmith logs every single step, you can inspect the exact token count and latency of these CoreMedia Content Cloud property extractions. It keeps your production chains fast and prevents your agent from getting lost in deep nesting loops.

Setup guide

Set up CoreMedia Content Cloud 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 CoreMedia Content Cloud 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({
    "coremedia-content-cloud-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 CoreMedia Content Cloud 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 CoreMedia. 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 CoreMedia Content Cloud 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 CoreMedia Content Cloud MCP in LangChain

Install `langchain-mcp-adapters`, set up the `MultiServerMCPClient` with your Vinkius endpoint, and call `client.get_tools()`. You can pass these tools directly to your agent constructor, allowing it to run `get_site_context` or `search_global_content` on your CoreMedia setup.

Yes. Your agent can run `get_cmchannel_page` to find active layouts, and then immediately feed those layout rules into `get_cmarticle_path` in the next step of the chain. This multi-step reasoning happens entirely within your LangChain execution loop.

Use LangSmith to trace the exact input payloads passed to tools like `execute_persisted_query` or `get_cmviewtypes`. You will see the raw JSON inputs and the returned errors or schema limits directly in your tracing dashboard.

Yes, you can combine this server with other APIs in a single `MultiServerMCPClient`. Your LangChain agent can query CoreMedia layout rules and then send that data to a database tool in a single, unified chain.

Vinkius processes your CoreMedia schema boundaries, CMArticle properties, and database bytes in memory inside an ephemeral V8 sandbox, ensuring your API credentials never leak to the LangChain execution environment.

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