4,500+ servers built on MCP Fusion
Vinkius

rct.ai MCP. Control NPC behavior and narrative state.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

rct.ai MCP on Cursor AI Code Editor MCP Client rct.ai MCP on Claude Desktop App MCP Integration rct.ai MCP on OpenAI Agents SDK MCP Compatible rct.ai MCP on Visual Studio Code MCP Extension Client rct.ai MCP on GitHub Copilot AI Agent MCP Integration rct.ai MCP on Google Gemini AI MCP Integration rct.ai MCP on Lovable AI Development MCP Client rct.ai MCP on Mistral AI Agents MCP Compatible rct.ai MCP on Amazon AWS Bedrock MCP Support

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.

+ 7 more capabilities included
Define Character Profiles

Creates a new, detailed AI NPC profile using create_character.

Run Conversational Inference

Sends text input to an existing NPC and gets a natural response back via the send_inference tool.

Manage Interaction State

Initializes or retrieves details about an ongoing user-NPC conversation session using create_session and get_session.

Update Character Parameters

Modifies the traits, personality, or knowledge base of a character with update_character.

Control Narrative Randomness

Read or adjust the parameters that govern story flow and unpredictable events using get_chaos_box_config and update_chaos_box_config.

List Character Assets

Retrieves a list of knowledge bases or assets tied to specific characters via list_assets.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

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.

create019d8475

create character

Creates a new AI NPC profile with defined traits and knowledge bases.

create019d8475

create session

Starts a fresh, persistent interaction session between the user and an NPC.

get019d8475

get chaos box config

Retrieves the current parameters that control narrative randomness and logic flow for NPCs.

get019d8475

get character

Fetches all detailed configuration data for a specific, existing AI character ID.

get019d8475

get session

Retrieves the full context and status of an ongoing user-NPC interaction session.

list019d8475

list assets

Lists all attached knowledge bases or data assets available for a character to reference.

list019d8475

list characters

Returns an index of every AI character currently defined and managed in your account.

send019d8475

send inference

Sends user input to a specific NPC and receives a generated, context-aware response.

update019d8475

update chaos box config

Changes the parameters governing how randomized or structured the narrative decisions should be.

update019d8475

update 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
Start building

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. 1 First, you must subscribe to the rct.ai MCP Server on Vinkius.
  2. 2 Next, sign up at rct.ai and generate your API Key after gaining Morpheus Cloud access.
  3. 3 Finally, configure your AI client to use this key when calling tools like send_inference or list_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.

Game Developer

Uses create_character to build varied NPC types and then uses send_inference to write non-linear quest responses.

Metaverse Architect

Deploys multiple autonomous agents across a virtual space, managing their state with list_characters and ensuring persistent context via create_session.

Narrative Designer

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.

Real-World Use Cases

01

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.

02

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.

03

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.

04

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

How we secure it →

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

create_character create_session get_chaos_box_config get_character get_session list_assets list_characters send_inference update_chaos_box_config update_character

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.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 10 tools

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.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

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.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.