How to Use the Flipt MCP in LangChain

Q: How do I connect the Flipt MCP Server to my LangChain agent?

Install langchain-mcp-adapters via pip and configure the MultiServerMCPClient with the server URL. Once connected, call client.gettools() to pass the Flipt tools directly to your LangChain agent.

Q: Can LangChain trace unauthorized Flipt configuration changes?

Yes, every call to createvariant or createconstraint is traced inside LangSmith. You get a complete visual timeline of how your LangChain agent interacted with your Flipt server.

Q: Can I limit the agent to only read Flipt configurations?

Yes, you can configure your MCP client to only register listflags, listnamespaces, and listsegments. This prevents the agent from calling write tools like createvariant in production.

LangChain agents can now inspect and adjust your Flipt feature flags mid-chain based on real-time execution data.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Flipt MCP to LangChain

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

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Trace Flipt updates in LangSmith

Your LangChain agent uses `list_flags` and `list_namespaces` to audit current flag states before routing traffic to a new deployment. By integrating these tools directly into your active chains, you can verify configuration status right in LangSmith traces. LangSmith records every tool call, giving you a clear audit trail of which agent modified which flag. This visibility means you do not have to guess why a specific prompt version was enabled or disabled during a complex chain execution.

Dynamic LangChain MCP Server routing

The `create_variant` and `create_distribution` tools allow your ReAct agent to adjust flag configurations on the fly when performance metrics dip. This MCP Server exposes these tools so your chains can automate canary rollouts without manual human intervention. Because LangChain supports multi-server aggregation, you can combine these feature flag adjustments with database writes or monitoring alerts in a single step. Your agent evaluates the context, decides the optimal variant distribution, and applies it immediately.

Segment targeting via LangChain pipelines

Target specific user groups dynamically using `create_constraint` and `list_segments` within your LangChain pipeline. These tools let your pipeline inspect existing user segments and apply strict rules to them based on live chain outputs. This MCP capability keeps your application logic clean and moves the targeting decisions directly to the edge. Instead of hardcoding user targeting rules in your codebase, you let your LangChain agent evaluate the current user context and build the constraint rules.

Setup guide

Set up Flipt 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 Flipt 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({
    "flipt-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 Flipt 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 Flipt. 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 Flipt 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 Flipt MCP in LangChain

Install `langchain-mcp-adapters` via pip and configure the `MultiServerMCPClient` with the server URL. Once connected, call `client.get_tools()` to pass the Flipt tools directly to your LangChain agent.

Yes, every call to `create_variant` or `create_constraint` is traced inside LangSmith. You get a complete visual timeline of how your LangChain agent interacted with your Flipt server.

Your LangChain agent should run sequential chains or use state locks in LangGraph to prevent race conditions. If two chains call `create_distribution` at the same time, Flipt handles the API queue, but LangChain's state management keeps the agent execution orderly.

Yes, you can configure your MCP client to only register `list_flags`, `list_namespaces`, and `list_segments`. This prevents the agent from calling write tools like `create_variant` in production.

Your feature flag names, namespace lists, and segment constraints stay within your local network or Vinkius sandbox. LangChain only passes these metadata strings to your language model if you explicitly include them in the prompt context.

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