Skip to main content

​
Overview

What it does

Echo is a testing and learning tool that helps you understand how MCP servers work. It echoes back any message you send, with optional formatting and timing, making MCP server behavior visible and testable.Key Features:
  • Echo back text messages with optional uppercase formatting
  • Test timing and delays with simulated processing
  • Validate JSON data structures with analysis
  • No external API or authentication required
  • Zero cost, no rate limits
  • Works completely offline
  • Perfect for MCP training and debugging
  • Instant response for quick testing

Use Cases

Echo is designed for testing, learning, and development:
  • Test Studio Setup: Verify MCP server connectivity
  • Learn MCP Basics: Understand how tools receive parameters
  • Debug Workflows: Test conversation flow logic
  • Train Teams: Teach MCP concepts without production APIs
  • Prototype Workflows: Design multi-step processes before production
  • Demo Capabilities: Show MCP functionality to clients
  • Validate Integration: Confirm Studio MCP integration works
  • Development Testing: Test your MCP client implementations
Development Tool: Echo is designed for testing and learning. It’s not intended for production business workflows. Use production MCP servers like DeepL, IPInfo, or Salesforce for actual business operations.

​
Quick Start

1

No API Key Needed

Echo is a local testing server that requires zero configuration.Benefits:
  • No signup or registration
  • No API keys to manage
  • No rate limits or quotas
  • No billing or costs
  • Works completely offline
  • Instant availability
  • No external dependencies
Echo is perfect for learning how MCP servers work before configuring production services with real API keys and costs.
2

Add to NimbleBrain Studio

  1. Open NimbleBrain Studio
  2. Navigate to Settings → MCP Servers
  3. Click Add Server
  4. Search for “Echo” in the server registry
  5. Click Add - no configuration needed!
  6. Server will show “Connected” status immediately
Setup takes less than 30 seconds. Echo is pre-configured and ready to use with zero setup.
3

Test the Connection

In your Studio chat, try this prompt:“Echo this message: Hello, World!”What happens:
  • Studio sends your message to Echo server
  • Echo processes and returns: “Hello, World!”
  • You see the 🔧 tool usage indicator
  • Response includes metadata (message length, timestamp)
If you see the echoed message, your MCP setup is working perfectly!

​
Available Tools

Echo back a text message with optional uppercase transformation. Perfect for testing basic MCP server connectivity and parameter passing.Parameters:
ParameterTypeRequiredDefaultDescription
messagestringYes-The text message to echo back
uppercasebooleanNofalseConvert message to uppercase
Returns:
  • original_message - Your original input message
  • echoed_message - The echoed message (transformed if uppercase=true)
  • uppercase_applied - Whether uppercase was applied
  • message_length - Length of the original message in characters
  • timestamp - ISO 8601 timestamp when echo occurred
Example Usage:Natural language in Studio:
"Echo this message: Testing 1, 2, 3"
With uppercase:
"Echo this in uppercase: hello world"
Example Response:
{
  "original_message": "Testing 1, 2, 3",
  "echoed_message": "Testing 1, 2, 3",
  "uppercase_applied": false,
  "message_length": 15,
  "timestamp": "2025-01-04T20:15:30.123456Z"
}
Watch for the 🔧 tool indicator in Studio to confirm the MCP tool was called vs a natural AI response.
Echo back a message after a simulated processing delay. Perfect for testing asynchronous operations, conversation flow timing, and understanding how Studio handles delayed responses.Parameters:
ParameterTypeRequiredDefaultDescription
messagestringYes-The text message to echo back
delay_secondsfloatNo1.0Delay duration in seconds (max: 5.0)
Returns:
  • original_message - Your original input message
  • echoed_message - The echoed message (unchanged)
  • requested_delay - The delay you requested in seconds
  • actual_delay - The actual delay experienced in seconds
  • start_time - ISO 8601 timestamp when delay started
  • end_time - ISO 8601 timestamp when delay ended
  • timestamp - ISO 8601 timestamp of operation completion
Example Usage:Natural language in Studio:
"Echo this message with a 2 second delay: Processing..."
Testing quick response:
"Echo 'Fast response' with 0.5 second delay"
Example Response:
{
  "original_message": "Processing...",
  "echoed_message": "Processing...",
  "requested_delay": 2.0,
  "actual_delay": 2.001234,
  "start_time": "2025-01-04T20:15:30.000000Z",
  "end_time": "2025-01-04T20:15:32.001234Z",
  "timestamp": "2025-01-04T20:15:32.001234Z"
}
Maximum delay is 5 seconds for safety. Requests above 5 seconds will be automatically capped at 5.0.
Use this tool to understand how Studio handles long-running operations and manages conversation state during delays.
Echo back structured JSON data with comprehensive analysis. Perfect for testing how Studio handles complex data structures, validating JSON parsing, and understanding data transformation between natural language and structured formats.Parameters:
ParameterTypeRequiredDescription
dataobjectYesJSON object to echo back and analyze
Returns:
  • original_data - Your original JSON data
  • echoed_data - The echoed JSON data (unchanged)
  • analysis - Detailed analysis including:
    • key_count - Number of keys in the JSON object
    • keys - List of all keys present
    • data_types - Type of each value (string, int, bool, etc.)
    • total_size - Total size in bytes
  • timestamp - ISO 8601 timestamp of operation
Example Usage:Natural language in Studio:
"Echo this JSON data: {\"name\": \"John\", \"age\": 30, \"active\": true}"
Testing complex structure:
"Validate this user data: {\"user\": \"sarah\", \"email\": \"[email protected]\", \"roles\": [\"admin\", \"user\"]}"
Example Response:
{
  "original_data": {
    "name": "John",
    "age": 30,
    "active": true
  },
  "echoed_data": {
    "name": "John",
    "age": 30,
    "active": true
  },
  "analysis": {
    "key_count": 3,
    "keys": ["name", "age", "active"],
    "data_types": {
      "name": "str",
      "age": "int",
      "active": "bool"
    },
    "total_size": 45
  },
  "timestamp": "2025-01-04T20:15:30.123456Z"
}
The analysis helps you understand how Studio converts natural language descriptions into structured JSON, and how data types are preserved during MCP tool calls.
Use this tool to verify JSON data structures before using production APIs that require specific formats (like Salesforce, HubSpot, or Airtable).

​
Authentication

No Authentication Required: Echo is a local testing server that requires no API keys, credentials, or external authentication.

​
Zero Configuration

Echo works immediately after enabling in Studio:
  • ✅ No signup required
  • ✅ No API keys to manage
  • ✅ No rate limits to monitor
  • ✅ No costs or billing
  • ✅ Works completely offline
  • ✅ Instant availability
  • ✅ No external dependencies
Echo is perfect for teaching your team how MCP servers work before implementing production services with authentication, rate limits, and API costs.

​
Why No Authentication?

Echo is designed as a learning and testing tool:
  1. Educational: Learn MCP concepts without external dependencies
  2. Debugging: Test Studio integration without API costs or rate limits
  3. Prototyping: Build workflows before connecting real services
  4. Demonstration: Show MCP capabilities in demos and training sessions
  5. Development: Test your own MCP client implementations
For production workflows with real business data, use authenticated servers like:

​
Example Workflows

  • Basic Echo Test
  • Parameter Testing
  • Timing & Delays
  • JSON Structure Testing
  • Multi-Step Flow
  • Team Training
  • Workflow Prototyping
  • Error Understanding
Scenario: Verify Studio can communicate with MCP serversYour Goal: Confirm your Studio MCP setup is working correctly before connecting production servers.Prompt:
"Use the echo server to repeat this: Testing MCP connectivity"
What happens:
  1. Studio receives your natural language request
  2. AI determines the Echo tool should be used
  3. Sends message parameter to echo_message tool
  4. Echo processes and returns the message
  5. Studio displays the result with 🔧 tool indicator
  6. You see confirmation that MCP is working
Results:
Original: "Testing MCP connectivity"
Echoed: "Testing MCP connectivity"
Length: 24 characters
Timestamp: 2025-01-04T20:15:30Z
Time: <1 secondBusiness Value: Confirms MCP infrastructure is functioning before configuring expensive production APIs
If this works, your Studio MCP setup is correct and you’re ready to add production servers!
All examples work in NimbleBrain Studio’s natural language interface - no code, CLI, or technical configuration required!

​
Troubleshooting

Issue: Echo server doesn’t respond to your promptsSymptoms:
  • No response after sending echo request
  • Timeout errors
  • “Server unavailable” messages
Solutions:
  1. Verify Server Status:
    • Go to Settings → MCP Servers
    • Find “Echo” in the list
    • Check if status shows “Connected” (green)
    • If “Disconnected” (red), click Reconnect
  2. Re-enable the Server:
    • Click Edit next to Echo server
    • Toggle off, then toggle back on
    • Click Save
    • Refresh your browser
  3. Check Browser Console:
    • Press F12 to open developer tools
    • Look for errors in Console tab
    • Report errors to support if found
  4. Test with Simple Prompt: 
    "Echo: test"
    If this works, issue may be with prompt phrasing
Echo runs locally in Studio’s infrastructure - no internet required. Connection issues are usually browser or session related.
Issue: Studio doesn’t use Echo tool when you expect it toSymptoms:
  • Natural AI response instead of tool usage
  • No 🔧 tool indicator shown
  • Echo server not being called
Cause: Studio’s AI decides when tools are needed. Ambiguous prompts may not trigger tools.Solutions:Use Explicit Language:✅ Good prompts (will trigger Echo):
  • “Echo this message: Hello World”
  • “Use echo to repeat: Testing”
  • “Echo server, send back: My message”
  • “Test echo with: Sample text”
❌ Ambiguous prompts (might not trigger Echo):
  • “Say Hello” (might just respond naturally)
  • “Repeat this” (might respond without tool)
  • “Hello World” (no clear tool request)
Force Tool Usage:
  • Explicitly mention “echo” in your prompt
  • Use phrases like “use echo”, “echo back”, “echo this”
  • Mention “echo server” or “echo tool” specifically
Studio’s AI is designed to use tools when necessary. For production servers, this works well. For Echo (a testing tool), be explicit to ensure the tool is called.
Issue: Confused about when Echo tool is used vs Studio’s natural AI responsesExplanation:Echo Server (MCP Tool):
  • Shows 🔧 tool usage indicator
  • Returns structured response with metadata
  • Processes through MCP protocol
  • Tests server connectivity
  • Demonstrates MCP behavior
  • Includes timing and analysis data
Studio Natural Response:
  • No tool indicator
  • Direct conversational response
  • Faster (no server call)
  • Uses AI’s knowledge directly
  • No server involved
Example Comparison:Prompt: “Hello”
  • Natural Response: “Hello! How can I help you today?”
  • No tool used - just AI responding
Prompt: “Echo: Hello”
  • Echo Tool Response: Shows 🔧 and structured data
  • Tool used - MCP server called
Always look for the 🔧 indicator to confirm Echo was used. If you don’t see it, rephrase your prompt to be more explicit about using the echo tool.
Issue: echo_with_delay doesn’t delay or delays wrong amountCommon Scenarios:Delay is Capped at 5 Seconds:
  • You requested 10 seconds but got 5
  • Cause: Maximum delay is 5 seconds for safety
  • Solution: Echo automatically caps at 5.0 seconds
  • Check actual_delay in response for real timing
Delay Seems Shorter/Longer:
  • Requested 2.0 seconds, got 2.1 seconds
  • Cause: Small variance due to processing overhead
  • Solution: This is normal - check actual_delay field
  • Variance is typically less than 0.01 seconds
No Delay at All:
  • Response is instant despite requesting delay
  • Cause: Parameter not passed correctly
  • Solution: Try explicit phrasing: 
    "Use echo_with_delay with message 'test' and delay_seconds 2"
The actual_delay field in the response shows the precise delay experienced, useful for learning about timing variance.
Issue: echo_json doesn’t accept your JSON dataCommon Causes:Invalid JSON Syntax:
❌ Bad: "Echo JSON: {name: John, age: 30}"
✅ Good: "Echo JSON: {\"name\": \"John\", \"age\": 30}"
Keys must be quoted in valid JSON.Single vs Double Quotes:
❌ Bad: "Echo JSON: {'name': 'John'}"
✅ Good: "Echo JSON: {\"name\": \"John\"}"
JSON requires double quotes.Complex Nested Structures:
  • Very deeply nested JSON might not parse well from natural language
  • Solution: Start with simple structures to test
  • Example: 
    "Echo this simple JSON: {\"test\": \"value\"}"
Studio’s JSON Interpretation:
  • Studio converts your natural language to JSON
  • May simplify or restructure
  • Check the original_data field to see what was sent
Start with simple JSON structures when learning. Once comfortable, gradually increase complexity.
Issue: Want to apply Echo testing patterns to production serversSolution: Use Echo as a template for testing real serversEcho Testing Pattern:
  1. Start with simplest tool/feature
  2. Verify basic connectivity
  3. Test parameter passing
  4. Validate response structure
  5. Test error cases
  6. Build to complex workflows
Apply to Production Servers:Example: Testing DeepL Translation:
1. "Translate 'hello' to Spanish" (basic test)
2. "Translate 'hello world' to French" (verify it works)
3. "Translate [paragraph] to German" (test with more content)
4. Build multi-language workflow
Example: Testing IPInfo:
1. "Get info for IP 8.8.8.8" (basic test)
2. "Check if IP is from VPN" (specific feature)
3. "Analyze these IPs: [list]" (batch operation)
Echo teaches you the testing methodology. Apply the same systematic approach to any MCP server.
Issue: Echo never fails - how do I learn error handling?Explanation:Echo is intentionally simple and reliable. For error handling training:Use Production Servers for Error Scenarios:
  1. Rate Limit Errors:
    • Use DeepL free tier (500K chars/month)
    • Exceed quota to see rate limit messages
  2. Authentication Errors:
    • Use Abstract API with wrong key
    • See authentication failure messages
  3. Validation Errors:
    • IPInfo with invalid IP format
    • See validation error responses
  4. Data Format Errors:
    • Send wrong data structure to Salesforce
    • Learn about schema validation
Echo’s Role:
  • Perfect for “happy path” testing
  • Confirms MCP infrastructure works
  • Tests conversation flow logic
  • Validates data structures
Production Servers’ Role:
  • Real-world error scenarios
  • Rate limiting behavior
  • Authentication failures
  • Data validation errors
Echo’s reliability makes it perfect for testing success scenarios, but you need real servers to learn comprehensive error handling.

GitHub Repository

View source code, report issues, and contribute to Echo MCP Server

MCP Protocol Documentation

Learn about the Model Context Protocol specification

NimbleBrain Studio

Access your Studio workspace to start testing Echo

Report Issues

Found a bug or have a suggestion? Submit on GitHub

​
Next Steps: Production MCP Servers

Once you’re comfortable with Echo and understand MCP basics, explore production-ready MCP servers for real business workflows.
1

Master Echo Basics

Spend 15-30 minutes testing all Echo tools. Understand:
  • How tools are triggered
  • How parameters work
  • How responses are structured
  • How timing works
  • How data flows
2

Choose Your First Production Server

Based on your needs:For Content & Translation:
  • DeepL - Professional translation
For Data Validation:For Intelligence & Analytics:
  • IPInfo - IP geolocation and intelligence
For Financial Data:
  • Finnhub - Stock market and company data
3

Apply Echo Testing Patterns

Use the same systematic approach:
  1. Test basic connectivity
  2. Try simple operations
  3. Validate parameters and responses
  4. Build complex workflows
  5. Handle errors gracefully
4

Scale to Production

Graduate to production workflows:
  • Connect CRM systems (Salesforce, HubSpot)
  • Integrate communication tools (Gmail, Slack)
  • Build automation pipelines
  • Create business intelligence workflows

​
Production Server Comparison

DeepL Translation

Perfect for: Content localization, multilingual supportFree Tier: 500K characters/monthUse After Echo: Translate content, support global customers

IPInfo Intelligence

Perfect for: Fraud detection, personalizationFree Tier: 50K requests/monthUse After Echo: Analyze visitors, detect threats

Abstract API Validation

Perfect for: Data quality, validationFree Tier: 100-20,000/month per serviceUse After Echo: Validate emails, phone numbers, data

Finnhub Financial

Perfect for: Market analysis, financial researchFree Tier: 60 calls/minuteUse After Echo: Track stocks, analyze companies

Browse All Servers

Explore: 50+ production MCP serversCategories: CRM, Communication, Data, Finance, Travel, WeatherNext Step: Find servers for your workflows

​
Learning Resources

MCP (Model Context Protocol) Basics:MCP servers extend AI capabilities by connecting to external services and providing specialized tools:Key Concepts:
  • Tools: Functions that AI can call (like echo_message)
  • Parameters: Input data for tools (like message, uppercase)
  • Returns: Structured responses with data (like timestamps, analysis)
  • Context: Conversation state maintained across calls
How It Works:
  1. You send a natural language request
  2. Studio’s AI decides if tools are needed
  3. Calls appropriate MCP server tool(s)
  4. Processes the structured response
  5. Responds to you conversationally
Echo’s Educational Value:
  • Makes this process visible and understandable
  • Shows exact parameter passing
  • Displays structured responses
  • Demonstrates timing and flow
  • Safe environment for experimentation
Echo demonstrates MCP concepts in the simplest possible way, making it the perfect learning tool before production servers.
Studio Integration Architecture:Your Experience:
You → Natural Language → Studio AI → MCP Tool → Result → Natural Response
What Happens Behind the Scenes:
  1. Prompt Analysis:
    • You type natural language
    • Studio’s AI analyzes intent
    • Determines if tools are needed
    • Selects appropriate server(s)
  2. Parameter Extraction:
    • AI extracts required parameters
    • Converts natural language to structured data
    • Validates parameter types
    • Prepares tool call
  3. MCP Tool Call:
    • Calls server tool with parameters
    • Waits for response (shows loading)
    • Receives structured data
    • Handles errors if any
  4. Response Integration:
    • Processes tool response
    • Integrates with conversation context
    • Formats for user display
    • Maintains conversation flow
Echo Makes This Visible:
  • See exact parameters sent
  • View structured responses
  • Understand timing
  • Learn error handling
  • Build intuition for production use
This same architecture powers all MCP servers in Studio - from simple Echo to complex Salesforce integrations.
For Developers: Create Custom MCP ServersEcho’s simple codebase (only 3 tools!) makes it an excellent reference for learning MCP server development.Echo’s Architecture:
# 1. Define tools with @mcp.tool() decorator
@mcp.tool()
async def echo_message(message: str, uppercase: bool = False):
    # Tool implementation
    return EchoMessageResponse(...)

# 2. Use Pydantic models for type safety
class EchoMessageResponse(BaseModel):
    original_message: str
    echoed_message: str
    # ... more fields

# 3. Expose via FastMCP framework
app = mcp.streamable_http_app()
Learning Resources:Why Start with Echo:
  • Only 137 lines of code
  • No external API dependencies
  • Clear tool patterns
  • Type-safe responses
  • Good error handling
  • Well-documented
Next Steps for Developers:
  1. Study Echo’s source code
  2. Modify Echo to add your own tools
  3. Connect your own APIs
  4. Deploy to Studio
  5. Share with community
Echo’s MIT license allows you to use it as a template for your own MCP servers.
Understanding the Difference:Traditional API Integration:
1. Write code to call API
2. Handle authentication
3. Parse responses
4. Map to your data model
5. Handle errors in code
6. Deploy your application
7. Maintain API client code
MCP Server Approach:
1. Enable MCP server in Studio
2. Add API key in GUI
3. Use natural language
4. Studio handles everything
5. No code required
6. No deployment needed
7. No maintenance overhead
Benefits of MCP:
  • No Code: Natural language instead of programming
  • Managed: Studio handles infrastructure
  • Flexible: Change servers without code changes
  • Composable: Combine multiple services easily
  • Accessible: Business users can leverage APIs
When to Use Each:Use MCP When:
  • Business users need API access
  • Rapid prototyping required
  • Combining multiple services
  • No custom development resources
  • Conversational interface desired
Use Traditional APIs When:
  • Highly custom integration needed
  • Real-time performance critical
  • Specific SDK required
  • Embedded in application
  • Programmatic automation only
Echo helps you understand MCP’s value proposition by making server interactions transparent and accessible.
Lessons from Echo to Apply in Production:1. Start Simple:
  • Test basic connectivity first (like Echo)
  • Use simplest features before advanced
  • Verify one tool at a time
  • Build complexity gradually
2. Explicit Prompts:
  • Mention server name when ambiguous
  • Be specific about parameters
  • Clear about expected output
  • Reference tool names if needed
3. Verify Data Structures:
  • Test JSON formats with echo_json first
  • Validate structures before production APIs
  • Understand type requirements
  • Check size limits
4. Monitor Timing:
  • Use echo_with_delay to understand timing
  • Plan for API latency
  • Handle long-running operations
  • Set appropriate timeouts
5. Error Handling:
  • Test error scenarios early
  • Understand failure modes
  • Have fallback strategies
  • Monitor error rates
6. Cost Management:
  • Prototype with Echo (free) first
  • Understand rate limits
  • Monitor API usage
  • Use free tiers when learning
7. Security:
  • Never share API keys
  • Rotate keys regularly
  • Use minimum required permissions
  • Monitor for unusual activity
Echo teaches these patterns in a risk-free environment before applying them to production servers with costs and data sensitivity.

Need Help?

Support Channels:

Ready for Production?

Next Steps: