Skip to main content
Glama

hello

Say hello to a person by providing their name, receiving a friendly greeting in response.

Instructions

A simple hello world tool

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
nameYesThe name to say hello to

Implementation Reference

  • The 'hello' tool handler - executed when the tool is called. Returns a greeting message using the provided 'name' argument, defaulting to 'world'.
    case "hello": {
      return {
        content: [
          {
            type: "text",
            text: `Hello, ${args?.name || "world"}!`,
          },
        ],
      };
    }
  • Schema definition for the 'hello' tool, including its name, description, and input schema requiring a 'name' string property.
    {
      name: "hello",
      description: "A simple hello world tool",
      inputSchema: {
        type: "object",
        properties: {
          name: {
            type: "string",
            description: "The name to say hello to",
          },
        },
        required: ["name"],
      },
    },
  • The 'setupToolHandlers' method registers both ListToolsRequestSchema and CallToolRequestSchema handlers, registering the 'hello' tool among other tools.
    private setupToolHandlers() {
      this.server.setRequestHandler(ListToolsRequestSchema, async () => {
        const tools = [
          {
            name: "hello",
            description: "A simple hello world tool",
            inputSchema: {
              type: "object",
              properties: {
                name: {
                  type: "string",
                  description: "The name to say hello to",
                },
              },
              required: ["name"],
            },
          },
          {
            name: "generate_image",
            description:
              "Generate single or multiple images from text prompts with style and variation options",
            inputSchema: {
              type: "object",
              properties: {
                prompt: {
                  type: "string",
                  description: "The text prompt describing the image to generate",
                },
                outputCount: {
                  type: "number",
                  description:
                    "Number of variations to generate (1-8, default: 1)",
                  minimum: 1,
                  maximum: 8,
                  default: 1,
                },
                styles: {
                  type: "array",
                  items: { type: "string" },
                  description:
                    "Array of artistic styles: photorealistic, watercolor, oil-painting, sketch, pixel-art, anime, vintage, modern, abstract, minimalist",
                },
                variations: {
                  type: "array",
                  items: { type: "string" },
                  description:
                    "Array of variation types: lighting, angle, color-palette, composition, mood, season, time-of-day",
                },
                format: {
                  type: "string",
                  enum: ["grid", "separate"],
                  description:
                    "Output format: separate files or single grid image",
                  default: "separate",
                },
                seed: {
                  type: "number",
                  description: "Seed for reproducible variations",
                },
                preview: {
                  type: "boolean",
                  description:
                    "Automatically open generated images in default viewer",
                  default: false,
                },
              },
              required: ["prompt"],
            },
          },
          {
            name: "edit_image",
            description: "Edit an existing image based on a text prompt",
            inputSchema: {
              type: "object",
              properties: {
                prompt: {
                  type: "string",
                  description: "The text prompt describing the edits to make",
                },
                file: {
                  type: "string",
                  description: "The filename of the input image to edit",
                },
                preview: {
                  type: "boolean",
                  description:
                    "Automatically open generated images in default viewer",
                  default: false,
                },
              },
              required: ["prompt", "file"],
            },
          },
          {
            name: "restore_image",
            description: "Restore or enhance an existing image",
            inputSchema: {
              type: "object",
              properties: {
                prompt: {
                  type: "string",
                  description:
                    "The text prompt describing the restoration to perform",
                },
                file: {
                  type: "string",
                  description: "The filename of the input image to restore",
                },
                preview: {
                  type: "boolean",
                  description:
                    "Automatically open generated images in default viewer",
                  default: false,
                },
              },
              required: ["prompt", "file"],
            },
          },
          {
            name: "generate_icon",
            description:
              "Generate app icons, favicons, and UI elements in multiple sizes and formats",
            inputSchema: {
              type: "object",
              properties: {
                prompt: {
                  type: "string",
                  description:
                    "Description of the icon or UI element to generate",
                },
                sizes: {
                  type: "array",
                  items: { type: "number" },
                  description:
                    "Array of icon sizes in pixels (16, 32, 64, 128, 256, 512, 1024)",
                },
                type: {
                  type: "string",
                  enum: ["app-icon", "favicon", "ui-element"],
                  description: "Type of icon to generate",
                  default: "app-icon",
                },
                style: {
                  type: "string",
                  enum: ["flat", "skeuomorphic", "minimal", "modern"],
                  description: "Visual style of the icon",
                  default: "modern",
                },
                format: {
                  type: "string",
                  enum: ["png", "jpeg"],
                  description: "Output format",
                  default: "png",
                },
                background: {
                  type: "string",
                  description:
                    "Background type: transparent, white, black, or color name",
                  default: "transparent",
                },
                corners: {
                  type: "string",
                  enum: ["rounded", "sharp"],
                  description: "Corner style for app icons",
                  default: "rounded",
                },
                preview: {
                  type: "boolean",
                  description:
                    "Automatically open generated images in default viewer",
                  default: false,
                },
              },
              required: ["prompt"],
            },
          },
          {
            name: "generate_pattern",
            description:
              "Generate seamless patterns and textures for backgrounds and design elements",
            inputSchema: {
              type: "object",
              properties: {
                prompt: {
                  type: "string",
                  description:
                    "Description of the pattern or texture to generate",
                },
                size: {
                  type: "string",
                  description: 'Pattern tile size (e.g., "256x256", "512x512")',
                  default: "256x256",
                },
                type: {
                  type: "string",
                  enum: ["seamless", "texture", "wallpaper"],
                  description: "Type of pattern to generate",
                  default: "seamless",
                },
                style: {
                  type: "string",
                  enum: ["geometric", "organic", "abstract", "floral", "tech"],
                  description: "Pattern style",
                  default: "abstract",
                },
                density: {
                  type: "string",
                  enum: ["sparse", "medium", "dense"],
                  description: "Element density in the pattern",
                  default: "medium",
                },
                colors: {
                  type: "string",
                  enum: ["mono", "duotone", "colorful"],
                  description: "Color scheme",
                  default: "colorful",
                },
                repeat: {
                  type: "string",
                  enum: ["tile", "mirror"],
                  description: "Tiling method for seamless patterns",
                  default: "tile",
                },
                preview: {
                  type: "boolean",
                  description:
                    "Automatically open generated images in default viewer",
                  default: false,
                },
              },
              required: ["prompt"],
            },
          },
          {
            name: "generate_story",
            description:
              "Generate a sequence of related images that tell a visual story or show a process",
            inputSchema: {
              type: "object",
              properties: {
                prompt: {
                  type: "string",
                  description: "Description of the story or process to visualize",
                },
                steps: {
                  type: "number",
                  description: "Number of sequential images to generate (2-8)",
                  minimum: 2,
                  maximum: 8,
                  default: 4,
                },
                type: {
                  type: "string",
                  enum: ["story", "process", "tutorial", "timeline"],
                  description: "Type of sequence to generate",
                  default: "story",
                },
                style: {
                  type: "string",
                  enum: ["consistent", "evolving"],
                  description: "Visual consistency across frames",
                  default: "consistent",
                },
                layout: {
                  type: "string",
                  enum: ["separate", "grid", "comic"],
                  description: "Output layout format",
                  default: "separate",
                },
                transition: {
                  type: "string",
                  enum: ["smooth", "dramatic", "fade"],
                  description: "Transition style between steps",
                  default: "smooth",
                },
                format: {
                  type: "string",
                  enum: ["storyboard", "individual"],
                  description: "Output format",
                  default: "individual",
                },
                preview: {
                  type: "boolean",
                  description:
                    "Automatically open generated images in default viewer",
                  default: false,
                },
              },
              required: ["prompt"],
            },
          },
          {
            name: "generate_diagram",
            description:
              "Generate technical diagrams, flowcharts, and architectural mockups",
            inputSchema: {
              type: "object",
              properties: {
                prompt: {
                  type: "string",
                  description: "Description of the diagram content and structure",
                },
                type: {
                  type: "string",
                  enum: [
                    "flowchart",
                    "architecture",
                    "network",
                    "database",
                    "wireframe",
                    "mindmap",
                    "sequence",
                  ],
                  description: "Type of diagram to generate",
                  default: "flowchart",
                },
                style: {
                  type: "string",
                  enum: ["professional", "clean", "hand-drawn", "technical"],
                  description: "Visual style of the diagram",
                  default: "professional",
                },
                layout: {
                  type: "string",
                  enum: ["horizontal", "vertical", "hierarchical", "circular"],
                  description: "Layout orientation",
                  default: "hierarchical",
                },
                complexity: {
                  type: "string",
                  enum: ["simple", "detailed", "comprehensive"],
                  description: "Level of detail in the diagram",
                  default: "detailed",
                },
                colors: {
                  type: "string",
                  enum: ["mono", "accent", "categorical"],
                  description: "Color scheme",
                  default: "accent",
                },
                annotations: {
                  type: "string",
                  enum: ["minimal", "detailed"],
                  description: "Label and annotation level",
                  default: "detailed",
                },
                preview: {
                  type: "boolean",
                  description:
                    "Automatically open generated images in default viewer",
                  default: false,
                },
              },
              required: ["prompt"],
            },
          },
        ];
        return {
          tools,
        };
      });
Behavior1/5

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

No annotations provided and description omits behavioral traits like side effects, idempotency, or output format. Agent lacks essential context.

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

Conciseness3/5

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

Single sentence is concise but too vague; it sacrifices substance for brevity.

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

Completeness2/5

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

No output schema and description fails to explain tool's return value or behavior, leaving the agent underinformed.

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 covers parameter 'name' with description. Tool description adds no extra meaning, achieving baseline for high coverage.

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

Purpose2/5

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

The description 'A simple hello world tool' is vague; it does not specify the action or return value. It contrasts with image tools but lacks precision.

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

Usage Guidelines2/5

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 siblings. While siblings are image-related, no explicit when-to-use or when-not-to-use logic.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Aeven-AI/mcp-nanobanana'

If you have feedback or need assistance with the MCP directory API, please join our Discord server