ELIZA MCP Server
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@ELIZA MCP ServerI'm feeling anxious"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
ELIZA MCP Server
A Model Context Protocol (MCP) server that provides access to the classic ELIZA chatbot. ELIZA is a famous early natural language processing program that simulates a Rogerian psychotherapist.
Overview
This MCP server exposes ELIZA's conversational capabilities through a standardized interface, allowing LLMs to interact with this historic chatbot for demonstrations, examples, or entertainment purposes.
Related MCP server: MCP TypeScript Tools Server
Features
Stateful Conversations: Maintains conversation context across multiple interactions
Classic ELIZA Responses: Uses the original ELIZA algorithm from the elizabot npm package
Simple API: Four tools for complete control over ELIZA interactions
Installation
npm install
npm run buildUsage
With Claude Desktop
Add to your claude_desktop_config.json:
{
"mcpServers": {
"eliza": {
"command": "npx",
"args": ["elisa-mcp"]
}
}
}Standalone
npm startAvailable Tools
eliza_chat
Send a message to ELIZA and receive a response.
Parameters:
message(string, required): The message to send to ELIZA
Returns:
response(string): ELIZA's responsequit(boolean): Whether the user said a quit phrase
Example:
{
"message": "I'm feeling sad today"
}eliza_reset
Reset the ELIZA conversation, clearing all memory and starting fresh.
Parameters: None
Returns: Confirmation message
eliza_get_initial
Get ELIZA's initial greeting message to start a new conversation.
Parameters: None
Returns: ELIZA's greeting
eliza_get_final
Get ELIZA's farewell message when ending the conversation.
Parameters: None
Returns: ELIZA's farewell
Example Interaction
Get initial greeting:
Tool: eliza_get_initial
Response: "Hello. How are you feeling today?"Chat with ELIZA:
Tool: eliza_chat
Input: { "message": "I'm worried about my future" }
Response: { "response": "Why are you worried about your future?", "quit": false }Continue conversation:
Tool: eliza_chat
Input: { "message": "I don't know what I want to do" }
Response: { "response": "Do you often feel uncertain about what you want?", "quit": false }Reset if needed:
Tool: eliza_reset
Response: "ELIZA conversation has been reset..."How ELIZA Works
ELIZA uses pattern matching and substitution to simulate conversation. It:
Recognizes keywords and patterns in user input
Applies transformation rules to generate responses
Maintains a small memory of previous statements
Occasionally reflects earlier topics back to the user
The chatbot gives the illusion of understanding while using simple text manipulation techniques.
Technical Details
Built with the official MCP TypeScript SDK
Uses the
elizabotnpm package (v0.0.3)Maintains conversation state in memory
Communicates via stdio transport
References
License
MIT
Sources
This project was built using information from:
Available Tools
4 toolseliza_chatC
Send a message to ELIZA chatbot and receive a response. ELIZA is a classic chatbot that simulates a Rogerian psychotherapist.
| Name | Required | Description | Default |
|---|---|---|---|
| message | Yes | The message to send to ELIZA |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It implies a synchronous request/response and a non-destructive read-like interaction, but says nothing about session state persistence, whether the conversation accumulates context, or rate limits. The 'Rogerian psychotherapist' note is domain color, not tool behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the action and followed by a brief contextual clarification. No waste, though the second sentence is optional flavor rather than operational detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter tool with no output schema this is adequate on the surface, but the sibling set reveals stateful semantics (reset, initial, final) that the description never addresses. An agent cannot tell whether calls share conversation state or how they relate to eliza_reset.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There is a single parameter with 100% schema description coverage, so the schema already explains 'message'. The description adds no format, length, or content constraints beyond what the schema provides; baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb+resource ('Send a message to ELIZA chatbot and receive a response') and the second sentence clarifies what ELIZA is. It does not explicitly differentiate itself from siblings like eliza_reset or eliza_get_initial, but the core action is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus the sibling tools (eliza_reset, eliza_get_initial, eliza_get_final). The presence of eliza_reset strongly implies stateful conversation, yet nothing tells the agent when a chat call is appropriate or what ordering constraint applies.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
eliza_get_finalA
Get ELIZA's farewell message when ending the conversation.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden. 'Get' implies a read-only retrieval, but it does not state whether the call changes state, requires permissions, or has side effects. For a simple getter this is minimally adequate, but richer behavioral context is absent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence with no wasted words, front-loading the verb and resource before the timing context. It is appropriately sized for a trivial getter.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (zero parameters, no output schema, no annotations), the description covers purpose and timing sufficiently. It could state the return format more explicitly, but the low complexity means little is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and the schema description coverage is 100%, so there is nothing for the description to clarify. Per the rubric, zero params yields a baseline of 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Get' and resource 'ELIZA's farewell message,' and scopes it to 'when ending the conversation.' It implicitly distinguishes from siblings like eliza_get_initial (initial greeting) and eliza_chat, but does not explicitly name an alternative. This is clear, though not maximally differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
States the trigger context ('when ending the conversation'), which tells the agent when to call it. It does not mention alternatives such as eliza_get_initial or eliza_reset, nor when not to use it. So it provides clear context but no explicit alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
eliza_get_initialA
Get ELIZA's initial greeting message to start a new conversation.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states what the tool does but doesn't disclose key behaviors: whether calling it resets state, whether it's idempotent, or what exactly is returned (the greeting message text, a message object, etc.). For a zero-argument tool in a conversational context, more behavioral context is needed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, well-structured sentence that is front-loaded with the core action ('Get ELIZA's initial greeting message') and adds a succinct usage note. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity (no params, no output schema), the description is adequate but not complete. It doesn't explain what happens if called mid-conversation, whether it resets anything, or what the response format is. For a tool in a chat context, these details matter, though the bare minimum is met.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so parameter semantics is largely irrelevant. The baseline is 4. The description doesn't need to explain parameters, and it correctly doesn't.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: retrieve ELIZA's initial greeting. It clearly distinguishes itself from siblings like eliza_chat (which likely sends a message) and eliza_get_final (which retrieves the final message). The scope is narrow and well-defined.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'to start a new conversation' clearly indicates when to use this tool, implying it should be called first. However, it doesn't explicitly name alternatives or state when not to use it, e.g., if a conversation already exists. Still, the context is strong.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
eliza_resetA
Reset the ELIZA conversation, clearing all memory and starting fresh.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears full disclosure burden. It discloses the key behavior (clearing all memory, fresh start), which is useful, but doesn't mention reversibility, auth requirements, or side effects beyond the obvious. Adequate but incomplete.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded with the action and effect, with zero waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a parameterless tool with no annotations and no output schema, the description covers the main action but omits potential side effects or return value hints. It's minimally sufficient but could say more about what 'fresh' entails.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Zero parameters, so baseline is 4. The description correctly implies no inputs are needed, aligning with the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (reset) and resource (ELIZA conversation) and clarifies the effect: clearing memory and starting fresh. It distinguishes itself from siblings like eliza_chat by describing a state-clearing action, though it doesn't explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage (when you want to clear memory), but offers no explicit when-to-use vs. alternatives guidance. It's clear enough from context but lacks direct routing to siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
v1.0.0- First observed
eliza_chat - First observed
eliza_get_final - First observed
eliza_get_initial - First observed
eliza_reset
TDQS
Scored across 4 tools
Each tool has a clearly distinct purpose: chat, reset, get initial greeting, and get final farewell. No overlap in functionality.
All tools follow a consistent snake_case pattern with the 'eliza_' prefix, making them predictable and easy to distinguish.
Four tools provide a well-scoped set that covers the essential operations for interacting with a simple chatbot without redundancy.
The toolset covers the full conversation lifecycle: starting (initial greeting), interacting (chat), resetting, and ending (final farewell). No obvious gaps.
Maintenance
Related MCP Connectors
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Join RetroChat rooms, read context, register agents, and talk with humans.
A Model Context Protocol server for Wix AI tools
Run AI customer support from your terminal: conversations, knowledge base, and chat widget.
Related MCP Servers
- AlicenseBqualityDmaintenanceProvides seamless access to Grok AI models through the Model Context Protocol by wrapping the official Grok CLI, offering tools for general queries, multi-turn conversations, and code generation.38MIT
- AlicenseNot gradedqualityDmaintenanceProvides calculator, datetime, and note-taking tools for LLMs like Claude via the Model Context Protocol.681 npmMIT
- FlicenseNot gradedqualityDmaintenanceA Model Context Protocol implementation for managing context, prompts, and model interactions in Meetup applications.1-
- FlicenseNot gradedqualityCmaintenanceProvides basic greeting, math, and date utilities for AI assistants via the Model Context Protocol.-