Skip to main content
Glama
gustavorobertux

MCP Greeting Server

🌍 MCP Greeting Server

A Model Context Protocol (MCP) server that provides intelligent, time-aware greetings in multiple languages and timezones.

✨ Features

  • 🕐 Time-aware greetings - Automatically says good morning, afternoon, or evening based on current time

  • 🌍 Multi-language support - English, Portuguese, Spanish, and French

  • 🌎 Timezone flexibility - Works with any timezone (defaults to Brazil/São Paulo)

  • 👤 Personalization - Optional name parameter for personalized greetings

  • 🎯 MCP Compatible - Ready to use with Claude and other MCP clients

Related MCP server: Time MCP Server

🚀 Quick Start

Prerequisites

  • Node.js 18+

  • npm or yarn

Installation

# Clone the repository
git clone https://github.com/gustavorobertux/mcp-greeting-server.git
cd mcp-greeting-server

# Install dependencies
npm install

# Start the server
npm start

🔧 Claude Configuration

Method 1: Claude Desktop App

  1. Install Claude Desktop from Claude.ai

  2. Locate the configuration file:

    # Windows
    %APPDATA%\Claude\claude_desktop_config.json
    
    # macOS
    ~/Library/Application Support/Claude/claude_desktop_config.json
    
    # Linux
    ~/.config/Claude/claude_desktop_config.json
  3. Add the MCP server configuration:

    {
      "mcpServers": {
        "greeting": {
          "command": "node",
          "args": ["/full/path/to/mcp-greeting-server/index.js"]
        }
      }
    }
  4. Restart Claude Desktop and you'll see the greeting tool available!

Method 2: Claude Web/API with MCP Client

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

// Connect to the greeting server
const transport = new StdioClientTransport({
  command: "node",
  args: ["/path/to/mcp-greeting-server/index.js"]
});

const client = new Client({
  name: "greeting-client",
  version: "1.0.0"
}, {
  capabilities: {}
});

await client.connect(transport);

// Use the greeting tool
const result = await client.request({
  method: "tools/call",
  params: {
    name: "greet",
    arguments: {
      name: "Alice",
      language: "en"
    }
  }
});

console.log(result.content[0].text);

Method 3: NPX (Quick Test)

# Run directly with npx (after publishing to npm)
npx mcp-greeting-server

# Or clone and run locally
git clone https://github.com/gustavorobertux/mcp-greeting-server.git
cd mcp-greeting-server
npm install
npm start

Troubleshooting

Issue: Claude Desktop doesn't show the greeting tool

  • ✅ Check file path is absolute

  • ✅ Verify Node.js is in PATH

  • ✅ Restart Claude Desktop completely

  • ✅ Check Claude Desktop logs for errors

Issue: Permission denied

# Make the script executable (Linux/macOS)
chmod +x index.js

# Or run with node explicitly
"command": "node"

Issue: Module not found

# Install dependencies in the project folder
cd /path/to/mcp-greeting-server
npm install

MCP Configuration

Add to your MCP client configuration:

{
  "mcpServers": {
    "greeting": {
      "command": "node",
      "args": ["/absolute/path/to/mcp-greeting-server/index.js"]
    }
  }
}

🧪 Testing with Claude

Once configured, you can test in Claude:

Hey Claude, can you greet me?

Claude will use the greet tool and respond with a time-appropriate greeting!

Hey Claude, greet me in Portuguese with my name "João"

Claude will call: greet({ name: "João", language: "pt" })

📖 Usage

With Claude

Once configured with Claude, simply ask for greetings naturally:

User: "Hey Claude, can you greet me?"
Claude: Uses greet() → "🌅 Good morning! friend! 🤝 It's 09:30 now. Hope you're having a great time!"

User: "Greet me in Portuguese as João"  
Claude: Uses greet({name: "João", language: "pt"}) → "☀️ Boa tarde! João! 🤝 São 14:30 agora. Espero que esteja tendo um ótimo momento!"

Direct API Usage

Basic Greeting

// Simple greeting (uses defaults: English, current timezone)
greet()
// Output: "🌅 Good morning! friend! 🤝\n\nIt's 09:30 now. Hope you're having a great time!"

Personalized Greeting

// With name
greet({ name: "Alice" })
// Output: "☀️ Good afternoon! Alice! 🤝\n\nIt's 14:30 now. Hope you're having a great time!"

Multi-language Support

// Portuguese
greet({ name: "João", language: "pt" })
// Output: "🌅 Bom dia! João! 🤝\n\nSão 09:30 agora. Espero que esteja tendo um ótimo momento!"

// Spanish
greet({ name: "María", language: "es" })
// Output: "🌙 ¡Buenas noches! María! 🤝\n\nSon las 21:30 ahora. ¡Espero que estés teniendo un gran momento!"

// French
greet({ name: "Pierre", language: "fr" })
// Output: "☀️ Bon après-midi! Pierre! 🤝\n\nIl est 15:30 maintenant. J'espère que vous passez un bon moment!"

Different Timezones

// New York time
greet({ timezone: "America/New_York" })

// London time
greet({ timezone: "Europe/London" })

// Tokyo time
greet({ timezone: "Asia/Tokyo" })

⚙️ API Reference

Tool: greet

Description: Returns an appropriate greeting based on the current time

Parameters:

Parameter

Type

Required

Default

Description

name

string

No

-

Person's name for personalization

timezone

string

No

America/Sao_Paulo

Timezone for the greeting

language

string

No

en

Language code (en, pt, es, fr)

Example Response:

{
  "content": [
    {
      "type": "text",
      "text": "🌅 Good morning! Alice! 🤝\n\nIt's 09:30 now. Hope you're having a great time!"
    }
  ]
}

🌐 Supported Languages

Language

Code

Example

English

en

"Good morning! friend!"

Portuguese

pt

"Bom dia! amigo!"

Spanish

es

"¡Buenos días! amigo!"

French

fr

"Bonjour! ami!"

🕐 Time Periods

Time Range

Greeting Type

Emoji

05:00 - 11:59

Morning

🌅

12:00 - 17:59

Afternoon

☀️

18:00 - 04:59

Evening/Night

🌙

🛠️ Development

Project Structure

mcp-greeting-server/
├── index.js          # Main server file
├── package.json       # Dependencies and scripts
├── README.md          # This file
└── .gitignore        # Git ignore rules

Running in Development

# Install dependencies
npm install

# Start the server
node index.js

# Or with npm script
npm start

Testing

# Test the greeting function
npm test

🤝 Contributing

  1. Fork the repository

  2. Create a feature branch (git checkout -b feature/amazing-feature)

  3. Commit your changes (git commit -m 'Add amazing feature')

  4. Push to the branch (git push origin feature/amazing-feature)

  5. Open a Pull Request

Adding New Languages

To add support for a new language:

  1. Add the language to the greetings object in handleGreet method

  2. Include translations for: morning, afternoon, evening, friend, timeText, hopeText

  3. Update the README.md supported languages table

  4. Add the language code to the schema enum

📝 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

  • Built with Model Context Protocol SDK

  • Inspired by the need for international, time-aware greetings

  • Perfect for Claude integrations and other MCP clients

📞 Support


Made with ❤️ for the MCP community

Available Tools

1 tool
greetA

Returns an appropriate greeting based on the current time (good morning, good afternoon, or good evening)

ParametersJSON Schema
NameRequiredDescriptionDefault
nameNoPerson's name to personalize the greeting (optional)
languageNoLanguage for the greeting (en, pt, es, fr)en
timezoneNoTimezone for the greeting (defaults to America/Sao_Paulo)America/Sao_Paulo

TDQS

A4/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly communicates that the tool computes a greeting from the time of day and returns it, with no indication of side effects. It could still mention the role of the timezone parameter more explicitly, but the current time-based behavior is well disclosed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single front-loaded sentence that immediately states the action, output, and deciding factor. The parenthetical examples add clarity without unnecessary words, making it highly efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is simple, all parameters are optional and well-documented in the schema, and the description captures the main behavior. The only notable gap is that no output schema is present and the description does not explicitly state the return type, though the examples strongly imply a plain string greeting.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the input schema already documents all three parameters: name, language enum, and timezone default. The description adds value for the time-based behavior but does not add per-parameter meaning beyond the schema, so the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('Returns'), a clear resource ('an appropriate greeting'), and the core mechanism ('based on the current time'). It also gives concrete examples of the output ('good morning, good afternoon, or good evening'), making the tool's purpose unambiguous even without sibling comparisons.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no explicit when-to-use or when-not-to-use guidance, and no sibling tools exist to distinguish against. The use case is implied by the behavior description, but the tool does not actively instruct the agent on when it should be chosen.

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.

  1. 1 tool updatev1.0.0
    • First observedgreet

TDQS

A4.3/5.0

Scored across 1 tool

Disambiguation5/5

Only one tool exists, so there is no possibility of confusion or overlap. The single 'greet' tool is unambiguous in its purpose.

Naming Consistency5/5

The tool name 'greet' is a clear, concise verb that directly matches the server's purpose. With only one tool, naming consistency is inherently maintained.

Tool Count5/5

The server's scope is limited to providing time-based greetings, and a single tool fully fulfills that purpose. The count is appropriate for the narrow, well-defined domain.

Completeness5/5

The tool covers the full range of greeting categories (morning, afternoon, evening) and requires no additional operations. The surface is completely sufficient for its stated purpose.

Maintenance

ActivityInactive
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    B
    quality
    D
    maintenance
    Provides time and timezone functionality for LLMs, enabling them to get current time information across different timezones and convert times between zones.
    2
    MIT
  • A
    license
    C
    quality
    D
    maintenance
    Provides current time and date information with timezone support and multiple formatting options. Enables AI assistants to answer time-related queries in different timezones with detailed temporal information.
    2
    6 npm
    MIT
  • A
    license
    Not graded
    quality
    C
    maintenance
    Enables AI assistants to greet users in 7 different languages including English, Spanish, French, German, Japanese, Chinese, and Korean. A lightweight multilingual greeting tool for the Model Context Protocol.
    MIT