rct.ai MCP for AI. Control NPC behavior and narrative state.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Connect to your AI in seconds.
rct.ai provides the engine to build, control, and simulate AI NPCs for games and metaverse worlds. This MCP gives your agent 10 tools to handle everything from creating a character profile (using `create_character`) to running complex interactions with an NPC via `send_inference`.
It lets you configure persistent narrative sessions (`create_session`), define character backstories, and control the underlying randomness using the Chaos Box algorithm.
Use it when your AI needs more than just simple chat—it needs a full lifecycle.
What your AI can do
Create character
Creates a new AI NPC profile with defined traits and knowledge bases.
Create session
Starts a fresh, persistent interaction session between the user and an NPC.
Get chaos box config
Retrieves the current parameters that control narrative randomness and logic flow for NPCs.
Creates a new, detailed AI NPC profile using create_character.
Sends text input to an existing NPC and gets a natural response back via the send_inference tool.
Initializes or retrieves details about an ongoing user-NPC conversation session using create_session and get_session.
Modifies the traits, personality, or knowledge base of a character with update_character.
Read or adjust the parameters that govern story flow and unpredictable events using get_chaos_box_config and update_chaos_box_config.
Retrieves a list of knowledge bases or assets tied to specific characters via list_assets.
Ask an AI about this
Waiting for input…
rct.ai MCP Server: 10 Tools for Character & Scene Ops
These tools let you define characters, manage their memory (sessions), update traits on the fly, and control the logic that makes your virtual world feel unpredictable.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using rct.ai on VinkiusCreate Character
Creates a new AI NPC profile with defined traits and knowledge bases.
Create Session
Starts a fresh, persistent interaction session between the user and an NPC.
Get Chaos Box Config
Retrieves the current parameters that control narrative randomness and logic flow...
Get Character
Fetches all detailed configuration data for a specific, existing AI character ID.
Get Session
Retrieves the full context and status of an ongoing user-NPC interaction session.
Send Inference
Sends user input to a specific NPC and receives a generated, context-aware response.
List Assets
Lists all attached knowledge bases or data assets available for a character to reference.
List Characters
Returns an index of every AI character currently defined and managed in your account.
Update Chaos Box Config
Changes the parameters governing how randomized or structured the narrative...
Update Character
Modifies any aspect of an existing character, like personality or lore, without...
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token
from cloud.vinkius.com. For OAuth-protected servers, expand
Advanced settings to add credentials.
Start a conversation
Open a new chat. The rct.ai integration is available immediately — no restart needed.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with rct.ai, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by rct.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.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 10 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Writing conversational NPCs that remember things shouldn't require state machines and databases.
Today, if your AI character needs to reference something that happened 15 minutes ago in the virtual world, you have to build a massive backend system. You write custom logic just to store those memory flags, track which session they belong to, and then feed that whole history back into the LLM prompt every single time.
With this MCP server, you handle it by calling `create_session`. The engine manages the context for you. Your agent sends a simple input via `send_inference`, and the NPC replies while respecting the full conversational history without you having to build or maintain any complex state machine.
rct.ai MCP Server: Define character traits & behaviors
The biggest headache is making NPCs feel alive—not just reciting canned responses. You can't simply send a message and expect the response to match the character defined weeks earlier in the backend. The personality drifts, or worse, it forgets who they are.
This server fixes that by allowing you to define core traits with `create_character`. When your agent runs an inference, it isn’t just talking; it's channeling a specific, persistent persona, making every reply feel like it came from a unique person.
What your AI can actually do with this
rct.ai gives you the engine to build and run autonomous NPCs for games or any metaverse world. You're not just running chat prompts; you're managing a character's entire life cycle—their history, their personality shifts, and how they react when things get unpredictable. This MCP hands your agent ten specific tools that handle everything from initial profile creation to simulating complex narrative decisions.
Character Setup: Building the NPC Core
You start by defining who these characters are. Using create_character, you build a brand-new AI profile, setting up all their core traits and giving them access to specific knowledge bases. Once that's done, if you need details on an existing character, running get_character pulls every piece of configuration data associated with that unique ID.
Want to tweak the lore or change their personality without starting over? Use update_character; it modifies any part of the profile—the traits, the background info, whatever—on the fly.
To keep track of everyone you've built, running list_characters gives you an index of every single character defined and managed in your account. Furthermore, if a character needs external context, running list_assets shows you all the attached knowledge bases or data assets that specific character can reference when talking to someone.
Running the Conversation: Interaction State Management
The whole point is interaction. You handle this by simulating real conversations. To start fresh, use create_session, which initializes a persistent chat session between your user and an NPC. This keeps the context clear, so the character remembers what was said minutes ago. When you need to know where things stand in that ongoing dialogue, running get_session pulls the full status and context of the current interaction.
For actual gameplay or conversation flow, you send text input to a specific NPC using send_inference; your agent receives a generated response that feels natural because it's tied directly to the character’s established personality and the session's history.
Controlling the Narrative: Logic and Randomness
The trickiest part of building NPCs is making them feel alive—meaning they can surprise you. You manage that with the Chaos Box logic. If you need to know what rules are governing how random or structured the story flow should be, use get_chaos_box_config to retrieve those current parameters. And when the narrative needs a major shift in tone—maybe it's getting too predictable, or maybe it needs more wild unpredictability—you adjust everything using update_chaos_box_config.
This tool lets you fine-tune the decision-making process that governs story flow and any unexpected events within your simulated world.
This system means your agent handles the entire lifecycle: from definition (create_character) to asset linking (list_assets), managing conversation state (get_session, send_inference), modifying character lore (update_character), and finally, controlling the underlying narrative structure itself (get_chaos_box_config). You've got everything you need for a full-scale simulation.
019d8475-a87a-7113-be90-caa3b27f87eb 
Here's how it actually works
The bottom line is that you need a developer account and an API key before any of the functions actually run.
First, you must subscribe to the rct.ai MCP Server on Vinkius.
Next, sign up at rct.ai and generate your API Key after gaining Morpheus Cloud access.
Finally, configure your AI client to use this key when calling tools like send_inference or list_characters.
Who is this actually for?
Game developers building complex quests, metaverse architects designing self-populating worlds, or narrative designers experimenting with emergent storytelling. You're the person tired of writing boring, predictable dialogue trees and needs NPCs that react like people—with flaws and memory.
Uses create_character to build varied NPC types and then uses send_inference to write non-linear quest responses.
Deploys multiple autonomous agents across a virtual space, managing their state with list_characters and ensuring persistent context via create_session.
Tests story outcomes by adjusting the Chaos Box logic using update_chaos_box_config to force specific types of plot unpredictability.
What Changes When You Connect
Character consistency isn't a guess anymore. Use get_character to pull up the full profile, ensuring your agent remembers that character’s specific history before running an inference.
Never lose context mid-conversation. The create_session and get_session tools keep track of every turn, so NPCs react logically, not just randomly, throughout a long quest arc.
Need the story to break free? Use update_chaos_box_config. You can dial up or down the randomness factor—it’s direct control over plot unpredictability.
Building complex worlds requires more than chatting. The list_assets tool lets you attach specific knowledge bases (like lore documents) that NPCs actually reference when they talk.
It handles the heavy lifting of communication. Just calling send_inference sends the input, and the engine returns a fully contextualized reply, saving your agent from hallucinating basic dialogue.
See it in action
The Quest Giver Needs to Change
A developer wants an NPC's role to change mid-game. Instead of rewriting the character, they use get_character first to check the current state. Then, they run update_character, changing key traits and adding a new lore asset via list_assets. The next time the agent runs send_inference, the NPC speaks with its new persona.
Debugging Strange NPC Behavior
An unexpected dialogue chain happens. Before reporting it, the team uses get_session to pull up the entire interaction history and context log. This proves whether the issue was a single input or if the underlying Chaos Box parameters needed adjustment using update_chaos_box_config.
Building a Starter World
An architect needs 10 distinct NPCs for a new zone. They start by running list_characters to see what's available, then loop through the list calling create_character ten times with specific backstories and knowledge bases. This rapidly populates the world with ready-to-use agents.
Testing High Stakes Story Arcs
A narrative designer needs to test how a critical dialogue scene plays out when high chaos is involved. They set up the initial context using create_session, then use get_chaos_box_config to confirm randomness parameters, and finally run multiple rounds of send_inference to see if the story breaks in interesting ways.
The honest tradeoffs
Treating NPCs like simple chatbots
Just sending a message and expecting a response. This ignores context, memory, and personality, resulting in generic replies that break immersion.
Don't just chat; manage the state first. Use create_session to establish context, then call send_inference. If the NPC needs new traits, use update_character before running the inference.
Losing track of who exists
Writing code that assumes a character ID exists when it might have been deleted or never created, leading to runtime errors.
Always run list_characters first. This gives you an accurate index of all IDs in your account before attempting to call get_character for any specific entity.
Assuming fixed plot outcomes
Coding a dialogue path that must happen, ignoring player agency or random events.
Don't hardcode the outcome. Read get_chaos_box_config and adjust it using update_chaos_box_config. This forces your system to incorporate stochastic randomness into the decision-making process.
When It Fits, When It Doesn't
Use rct.ai if your core problem is maintaining state, personality, or complex narrative flow over time. Specifically, if you need the NPC's response on turn 10 to logically depend on an action that happened in turn 2 (memory), this server handles it. Don't use it if you just need a simple messaging API; for basic chat functionality without character depth, standard message services are fine. However, if your 'chat' needs to feel like a world—with defined personalities and predictable failure modes—then the combination of create_character, send_inference, and get_chaos_box_config is exactly what you need.
Questions you might have
How do I make sure my NPC remembers lore details using rct.ai? +
You must first use list_assets to attach the specific knowledge base (the lore document) to the character profile, and then call update_character if you need to adjust which assets are active.
What is the difference between create_session and list_characters? +
list_characters just gives you an index of every NPC defined in your account. create_session starts a new, live interaction instance for one specific character.
Can I change the difficulty or randomness of story events with rct.ai? +
Yes. You use get_chaos_box_config to see the current settings, and then run update_chaos_box_config to adjust parameters like the randomness factor.
What if I update a character's traits, do I need to recreate them? +
No. You use update_character. This tool modifies an existing profile in place, preserving all their current session history and assets.
What credentials do I need before I can successfully use the `list_characters` tool? +
You must have an active Morpheus Cloud developer key. The server requires your API Key—generated in the developer console—for all operations, including listing characters and managing sessions.
If I use `send_inference` and receive a status error, what does that mean? +
An inference failure usually means the NPC timed out or hit an internal guardrail. Check the payload for a specific TIMEOUT code; this requires retrying the input with clearer context to guide the narrative.
What scope of data does the `get_character` tool provide? +
It returns all stored parameters, including personality traits, knowledge base references (assets), and the character's most recent behavioral state. This lets you audit the full profile before making any changes.
How do I handle high-volume messages without hitting rate limits? +
To maintain reliable throughput for repeated queries, group related calls into persistent sessions using create_session. This keeps your agent connected to the context and reduces overhead compared to starting new interactions every time.
What is the Chaos Box and how can I configure it? +
The Chaos Box is rct.ai's proprietary narrative engine. You can use the update_chaos_box_config tool to adjust decision-making parameters and balance stochastic randomness within your NPC interactions.
Can I manage persistent player sessions with my AI agent? +
Yes! Use the create_session and get_session tools to maintain context and state for individual players interacting with your virtual beings.
How do I list all assets attached to my characters? +
Use the list_assets tool. It will retrieve all knowledge bases and data sets currently associated with your Morpheus Cloud characters.
We've already built the connector for rct.ai. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 10 tools are live and waiting.
You're up and running in seconds.
Gemini Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.