rct.ai MCP. Control NPC behavior and narrative state.
Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
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 agents 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 AI about this MCP
Supported MCP Clients
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.
019d8475create character
Creates a new AI NPC profile with defined traits and knowledge bases.
019d8475create session
Starts a fresh, persistent interaction session between the user and an NPC.
019d8475get chaos box config
Retrieves the current parameters that control narrative randomness and logic flow for NPCs.
019d8475get character
Fetches all detailed configuration data for a specific, existing AI character ID.
019d8475get session
Retrieves the full context and status of an ongoing user-NPC interaction session.
019d8475list assets
Lists all attached knowledge bases or data assets available for a character to reference.
019d8475list characters
Returns an index of every AI character currently defined and managed in your account.
019d8475send inference
Sends user input to a specific NPC and receives a generated, context-aware response.
019d8475update chaos box config
Changes the parameters governing how randomized or structured the narrative decisions should be.
019d8475update character
Modifies any aspect of an existing character, like personality or lore, without recreating the profile.
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 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ 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
What you can do with this MCP connector
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.
How rct.ai MCP Works
- 1 First, you must subscribe to the rct.ai MCP Server on Vinkius.
- 2 Next, sign up at rct.ai and generate your API Key after gaining Morpheus Cloud access.
- 3 Finally, configure your AI client to use this key when calling tools like
send_inferenceorlist_characters.
The bottom line is that you need a developer account and an API key before any of the functions actually run.
Who Is rct.ai MCP 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_characterto 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_sessionandget_sessiontools 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_assetstool 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_inferencesends the input, and the engine returns a fully contextualized reply, saving your agent from hallucinating basic dialogue.
Real-World Use Cases
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 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.
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 server provides 10 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
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.
Common Questions About rct.ai MCP
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.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
SenseCore Platform
Orchestrate SenseCore AI services — manage models, trigger chat completions, and handle compute resources directly from any AI agent.
Oppo Game Open Platform
Manage Oppo Game Open Platform distribution — validate logins, query orders, and report game data directly from any AI agent.
Sensors Data
Orchestrate Sensors Data analytics — manage events, query user profiles, and monitor data ingestion directly from any AI agent.
You might also like
Curve Fitting Engine
Perform exact Linear and Polynomial regression on scatter plot data local. Get mathematically perfect coefficients, equations, and R-squared scores.
Cyberimpact
Email marketing automation with Cyberimpact.
ShowAPI / 易源数据
Massive API data marketplace — access weather, translation, stock info, and utilities via AI.