How to Use the Glow Loyalty MCP in LangChain

Q: How do I configure Glow Loyalty inside my LangChain setup?

Install the adapter using pip install langchain-mcp-adapters langgraph and initialize the MultiServerMCPClient with your HTTP endpoint. From there, pull the tools via client.gettools() and pass them directly to your agent executor.

Q: Can LangChain agents handle paginated member lists from Glow Loyalty?

Yes, the agent uses listmembersbypage to loop through your customer database. Because LangChain supports iterative loop execution, the agent can inspect pages sequentially until it finds the targeted member records.

Q: How does LangChain trace tool execution for Glow Loyalty?

Every tool invocation like adjustmemberpoints is automatically captured in LangSmith. You can monitor the exact inputs, outputs, and latency of each point modification to ensure your agent behaves correctly.

Q: How do I handle persistent context across sessions?

Use client.session() to spin up a persistent context state for your active conversation. This ensures that when the agent runs findloyaltymember, it remembers the customer's ID during subsequent calls to redeemloyaltyreward.

Build multi-step reasoning chains in LangChain that query customer balances and trigger point adjustments automatically.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Glow Loyalty MCP to LangChain

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

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Run multi-tool reasoning chains with this MCP Server

Connect your LangChain agents directly to the Glow Loyalty rewards program to handle support workflows without manual writing. By combining `get_member_balance` and `adjust_member_points` into a single ReAct loop, your agent checks a user's standing and applies corrective adjustments in one run. You can trace every transition in LangSmith to see exactly when the agent decided to pull up account identities using `get_program_details`. If a customer complains about a missing reward, the agent inspects the spec with `get_reward_spec` and runs the deduction in a single, observable sequence.

Build automated customer support loops

LangChain lets you link multiple steps together so your agent can resolve loyalty disputes without human intervention. The agent uses `find_loyalty_member` to locate the caller and then triggers `list_available_rewards` to explain what they can redeem right now. If the user is eligible, the agent calls `redeem_loyalty_reward` and reports the new balance immediately. This removes the latency of hopping between separate database lookups and support tools during a live chat.

Multi-server setups for complex tasks

Combine this rewards toolset with your database or CRM in a single LangChain graph using the `MultiServerMCPClient`. Your agent can fetch user profiles from your main database and instantly match them against loyalty signups using `list_new_members` to verify account status. If a discrepancy is found, the agent uses `gift_points_to_member` to issue a make-good bonus. This setup lets you run complex loyalty operations alongside 500 other integrations in the same execution graph.

Setup guide

Set up Glow Loyalty 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 Glow Loyalty 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({
    "glow-loyalty-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 Glow Loyalty 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 Glow Loyalty. 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 Glow Loyalty 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 Glow Loyalty MCP in LangChain

Install the adapter using `pip install langchain-mcp-adapters langgraph` and initialize the `MultiServerMCPClient` with your HTTP endpoint. From there, pull the tools via `client.get_tools()` and pass them directly to your agent executor.

Yes, the agent uses `list_members_by_page` to loop through your customer database. Because LangChain supports iterative loop execution, the agent can inspect pages sequentially until it finds the targeted member records.

Every tool invocation like `adjust_member_points` is automatically captured in LangSmith. You can monitor the exact inputs, outputs, and latency of each point modification to ensure your agent behaves correctly.

Use `client.session()` to spin up a persistent context state for your active conversation. This ensures that when the agent runs `find_loyalty_member`, it remembers the customer's ID during subsequent calls to `redeem_loyalty_reward`.

Your member profiles and point history remain secure because all API requests pass through Vinkius's isolated V8 sandboxes. Your sensitive credentials never leak into the LLM context or LangChain's tracing logs.

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