klbr/n8nworkflows.xyz
1
0
Fork 0
mirror of https://github.com/khoaliber/n8nworkflows.xyz.git synced 2026-04-25 03:09:09 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
02ddaf1486ae183734ea94de3f375073739a23d8
n8nworkflows.xyz/workflows/Telegram AI Chatbot-1934/readme-1934.md
T
nusquama 7ebb6ebc6b creation
2025-11-12 16:27:46 +01:00

20 KiB
Raw Blame History

Telegram AI Chatbot

https://n8nworkflows.xyz/workflows/telegram-ai-chatbot-1934

Telegram AI Chatbot

1. Workflow Overview

The Telegram AI Chatbot workflow enables interactive communication between Telegram users and an AI-powered chatbot leveraging OpenAI's services. It listens for incoming Telegram messages, then dynamically handles them based on their content:

  • Chat Messages: Replies with AI-generated text responses in the user's language.
  • Image Generation Commands: Creates and sends AI-generated images based on user prompts.
  • Unsupported Commands: Sends an error message guiding the user on valid commands.

The workflow also simulates typing or upload actions in Telegram for a more natural user experience and includes multiple sticky notes for documentation and guidance.

The workflow logic can be divided into these main blocks:

  • 1.1 Input Reception and Preprocessing: Captures Telegram messages and prepares data.
  • 1.2 Typing Action Simulation: Sends typing or upload indicators to Telegram.
  • 1.3 Command Analysis and Routing: Determines message type and routes to appropriate handler.
  • 1.4 Chatbot Text Response Handling: Generates and sends AI chat replies.
  • 1.5 Image Generation Handling: Creates and sends AI-generated images.
  • 1.6 Unsupported Command Handling: Sends an error message for unsupported commands.
  • 1.7 Documentation and Notes: Sticky notes providing explanations and user guidance.

2. Block-by-Block Analysis

1.1 Input Reception and Preprocessing

Overview:
This block listens to incoming Telegram messages and prepares the message text for further processing.

Nodes Involved:

  • Telegram Trigger
  • PreProcessing
  • Settings

Node Details:

  • Telegram Trigger

    • Type: Trigger
    • Role: Listens for all Telegram updates/messages to the bot.
    • Configuration: Listens to all update types (updates: ["*"]), uses Telegram bot credentials.
    • Inputs: External Telegram webhook
    • Outputs: Emits incoming message JSON objects.
    • Failures: Webhook connectivity issues, credential errors.
    • Version: 1

  • PreProcessing

    • Type: Set
    • Role: Extracts and normalizes the message text into a dot notation JSON field message.text.
    • Configuration: Sets message.text to the text of the Telegram message, or empty string if none.
    • Inputs: From Telegram Trigger
    • Outputs: JSON with normalized message text.
    • Edge Cases: Messages without text (e.g., stickers, images) are handled by setting empty string.
    • Version: 2

  • Settings

    • Type: Set
    • Role: Defines key parameters for AI model behavior and chat flow such as model temperature, max tokens, system prompt, and typing action.
    • Configuration:
      • model_temperature = 0.8 (controls AI creativity)
      • token_length = 500 (max token length for AI response)
      • system_command = System prompt instructing AI to behave as a friendly chatbot, detect user language, reply in the same language, and use emojis.
      • bot_typing = Conditional: if message starts with "/image" then "upload_photo" else "typing" (Telegram chat action).
    • Inputs: From PreProcessing
    • Outputs: Enhanced JSON including AI parameters and typing action.
    • Version: 2
    • Edge Cases: If message text is missing, bot_typing defaults to "typing".

1.2 Typing Action Simulation

Overview:
Simulates a typing or upload action in Telegram to improve user experience by signaling the bot is processing the user’s request.

Nodes Involved:

  • Send Typing action
  • Merge

Node Details:

  • Send Typing action

    • Type: Telegram
    • Role: Sends a chat action to Telegram (typing indicator or upload photo indicator) based on the bot_typing parameter.
    • Configuration:
      • action: Dynamic expression based on message type (typing or upload_photo).
      • chatId: User's chat ID from incoming message.
      • Operation: sendChatAction.
    • Inputs: From Settings
    • Outputs: Passes data downstream after sending the action.
    • Failures: Telegram API errors, invalid chat ID.
    • Version: 1

  • Merge

    • Type: Merge (chooseBranch mode)
    • Role: Combines outputs from Send Typing action and routes to command analysis.
    • Configuration: chooseBranch mode to select between multiple branches.
    • Inputs: From Send Typing action and Settings
    • Outputs: To CheckCommand node for command routing.
    • Version: 2.1

1.3 Command Analysis and Routing

Overview:
Determines the nature of the user message: greeting, chat message, image creation command, or unsupported command, then routes accordingly.

Nodes Involved:

  • CheckCommand

Node Details:

  • CheckCommand
    • Type: Switch
    • Role: Analyzes the message text to decide the processing branch.
    • Configuration:
      • Input: {{$json.message?.text}} (user message text)
      • Rules:
        • Output 1: If text does NOT start with "/" → regular chat message (chat mode).
        • Output 2: If text starts with "/start" → greeting mode.
        • Output 3: If text starts with "=/image " → image generation mode.
        • Fallback output (3): unsupported commands.
    • Inputs: From Merge
    • Outputs: Branches to Chat_mode, Greeting, Create an image, or Send error message nodes.
    • Edge Cases: Text with leading spaces or mixed case may not match; command parsing is literal and case-sensitive.
    • Version: 1

1.4 Chatbot Text Response Handling

Overview:
Generates a textual AI response using OpenAI's GPT-4 model and sends it back to the user via Telegram.

Nodes Involved:

  • Chat_mode
  • Text reply

Node Details:

  • Chat_mode

    • Type: OpenAI (Chat Completion)
    • Role: Sends prompt to OpenAI GPT-4 chat completion API to generate chatbot reply.
    • Configuration:
      • Model: gpt-4
      • Prompt: System message from system_command parameter, user message text as content.
      • Options: Max tokens and temperature dynamically set from parameters.
    • Inputs: From CheckCommand (chat message branch)
    • Outputs: AI-generated text in response.
    • Credentials: OpenAI API credentials needed.
    • Failures: Network errors, API rate limits, invalid credentials.
    • Version: 1

  • Text reply

    • Type: Telegram
    • Role: Sends the AI-generated text response to the Telegram user.
    • Configuration:
      • Text: AI message content from Chat_mode output.
      • Chat ID: Extracted dynamically from original user message.
      • Parse mode: Markdown for formatted text.
    • Inputs: From Chat_mode (and Greeting)
    • Outputs: To Telegram user.
    • Failures: Telegram API errors, invalid chat ID.
    • Version: 1

1.5 Image Generation Handling

Overview:
Handles image generation requests by creating AI images using OpenAI’s image API and sending them to users.

Nodes Involved:

  • Create an image
  • Send image

Node Details:

  • Create an image

    • Type: OpenAI (Image Generation)
    • Role: Calls OpenAI's image creation API with user prompt (message text after "/image" command).
    • Configuration:
      • Prompt: Extracted by splitting message text and joining words after the "/image" command.
      • Options: Generates 1 image, 512x512 pixels, response format is image URL.
    • Inputs: From CheckCommand (image command branch)
    • Outputs: Image URL in response.
    • Credentials: OpenAI API credentials needed.
    • Failures: API errors, invalid prompts, rate limits.
    • Version: 1

  • Send image

    • Type: Telegram
    • Role: Sends the generated image to the Telegram user as a photo.
    • Configuration:
      • File: URL of generated image from Create an image node.
      • Chat ID: User's chat ID from Settings node.
      • Operation: sendPhoto.
    • Inputs: From Create an image
    • Outputs: To Telegram user.
    • Failures: Telegram API errors, invalid URLs, chat ID errors.
    • Version: 1

1.6 Unsupported Command Handling

Overview:
Sends an error message to the user if an unsupported command is detected.

Nodes Involved:

  • Send error message
  • Sticky Note (Error fallback)

Node Details:

  • Send error message

    • Type: Telegram
    • Role: Sends a friendly error message guiding the user on supported commands.
    • Configuration:
      • Text: Personalized message with instructions on supported commands (/image [prompt]) with markdown formatting.
      • Chat ID: From user message.
      • Parse mode: Markdown.
    • Inputs: From CheckCommand fallback branch
    • Outputs: To Telegram user.
    • Failures: Telegram API errors, invalid chat ID.
    • Version: 1

  • Sticky Note (Error fallback)

    • Type: Sticky Note node
    • Role: Provides a visible note in workflow editor describing error fallback behavior.
    • Content: "Error fallback for unsupported commands"
    • Position: Near error handling nodes.
    • Inputs: None
    • Outputs: None

1.7 Documentation and Notes

Overview:
Sticky note nodes document various parts of the workflow for clarity and maintenance purposes.

Nodes Involved:

  • Sticky Note1 (Chatbot mode)
  • Sticky Note2 (Welcome message)
  • Sticky Note3 (Create an image)

Node Details:

  • Sticky Note1

    • Content: "Chatbot mode by default\n(when no command is provided)"
    • Positioned near Chat_mode node.

  • Sticky Note2

    • Content: "Welcome message\n/start"
    • Positioned near Greeting node.

  • Sticky Note3

    • Content: "Create an image\n/image + request"
    • Positioned near Create an image node.

3. Summary Table

Node Name Node Type Functional Role Input Node(s) Output Node(s) Sticky Note
Telegram Trigger Telegram Trigger Receive Telegram messages External webhook PreProcessing
PreProcessing Set Normalize message text Telegram Trigger Settings
Settings Set Define AI parameters & typing action PreProcessing Send Typing action, Merge
Send Typing action Telegram Send typing/upload action to user Settings Merge
Merge Merge Combine typing action and continue Send Typing action, Settings CheckCommand
CheckCommand Switch Route message by command type Merge Chat_mode, Greeting, Create an image, Send error message
Chat_mode OpenAI (Chat) Generate AI chat text response CheckCommand Text reply Sticky Note1: "Chatbot mode by default (when no command is provided)"
Greeting OpenAI (Chat) Generate greeting message CheckCommand Text reply Sticky Note2: "Welcome message /start"
Text reply Telegram Send AI-generated text to user Chat_mode, Greeting
Create an image OpenAI (Image) Generate image from prompt CheckCommand Send image Sticky Note3: "Create an image /image + request"
Send image Telegram Send generated image to user Create an image
Send error message Telegram Send unsupported command error CheckCommand Sticky Note: "Error fallback for unsupported commands"
Sticky Note Sticky Note Document error fallback "Error fallback for unsupported commands"
Sticky Note1 Sticky Note Document chatbot mode default "Chatbot mode by default (when no command is provided)"
Sticky Note2 Sticky Note Document welcome message "Welcome message /start"
Sticky Note3 Sticky Note Document image creation command "Create an image /image + request"

4. Reproducing the Workflow from Scratch

  1. Create Telegram Trigger Node

    • Type: Telegram Trigger
    • Configure to listen for all updates (updates: ["*"])
    • Use Telegram bot credentials with bot token
    • Position accordingly (e.g., x=20, y=340)

  2. Create PreProcessing Node

    • Type: Set
    • Enable dot notation
    • Set field message.text to {{$json?.message?.text || ""}}
    • Connect output of Telegram Trigger → PreProcessing

  3. Create Settings Node

    • Type: Set
    • Add parameters:
      • number: model_temperature = 0.8
      • number: token_length = 500
      • string: system_command = "You are a friendly chatbot. User name is {{ $json?.message?.from?.first_name }}. User system language is {{ $json?.message?.from?.language_code }}. First, detect user text language. Next, provide your reply in the same language. Include several suitable emojis in your answer."
      • string: bot_typing = {{$json?.message?.text.startsWith('/image') ? "upload_photo" : "typing"}}
    • Connect PreProcessing → Settings

  4. Create Send Typing action Node

    • Type: Telegram
    • Operation: sendChatAction
    • Action: {{$json.bot_typing}} (dynamic)
    • Chat ID: {{$json.message.from.id}}
    • Connect Settings → Send Typing action

  5. Create Merge Node

    • Type: Merge
    • Mode: chooseBranch
    • Connect Send Typing action → Merge (branch 0)
    • Connect Settings → Merge (branch 1)

  6. Create CheckCommand Node

    • Type: Switch
    • Value1: {{$json.message?.text}} (string)
    • Rules:
      • Output 1: NOT starts with "/" (regular chat)
      • Output 2: starts with "/start" (greeting)
      • Output 3: starts with "=/image " (image creation)
      • Fallback: unsupported command
    • Connect Merge → CheckCommand

  7. Create Chat_mode Node

    • Type: OpenAI (Chat Completion)
    • Model: gpt-4
    • Prompt messages:
      • System: from system_command parameter
      • User: {{$json.message.text}}
    • Options: maxTokens from token_length, temperature from model_temperature
    • Connect CheckCommand output 1 → Chat_mode

  8. Create Greeting Node

    • Type: OpenAI (Chat Completion)
    • Model: gpt-4
    • Prompt messages:
      • System: from system_command parameter
      • User: "This is the first message from a user. Please welcome a new user in '{{ $json.message.from.language_code }}' language"
    • Options: maxTokens from token_length, temperature from model_temperature
    • Connect CheckCommand output 2 → Greeting

  9. Create Text reply Node

    • Type: Telegram
    • Text: {{$json.message.content}} (output from Chat_mode or Greeting)
    • Chat ID: {{$('Settings').first().json.message.from.id}}
    • Parse mode: Markdown
    • Connect Chat_mode → Text reply
    • Connect Greeting → Text reply

  10. Create Create an image Node

    • Type: OpenAI (Image Generation)
    • Prompt: {{$json.message.text.split(' ').slice(1).join(' ')}}
    • Options: n=1, size=512x512, responseFormat=imageUrl
    • Connect CheckCommand output 3 → Create an image

  11. Create Send image Node

    • Type: Telegram
    • Operation: sendPhoto
    • File: {{$json.url}} (image URL from Create an image)
    • Chat ID: {{$('Settings').first().json.message.from.id}}
    • Connect Create an image → Send image

  12. Create Send error message Node

    • Type: Telegram
    • Text: 
      Sorry, {{$json.message.from.first_name}}! This command is not supported yet. Please type some text to a chat bot or try this command:

/image [your prompt]

Enter the command, then space and provide your request. Example:

`/image a picture or a cute little kitten with big eyes. Miyazaki studio ghibli style`
    • Chat ID: {{$json.message.from.id}}
    • Parse mode: Markdown
    • Connect CheckCommand fallback output → Send error message

  13. Add Sticky Notes (optional but recommended for maintenance)

    • Near Chat_mode: "Chatbot mode by default (when no command is provided)"
    • Near Greeting: "Welcome message /start"
    • Near Create an image: "Create an image /image + request"
    • Near Send error message: "Error fallback for unsupported commands"

  14. Activate workflow and test with various Telegram messages including:

    • Plain text chat messages
    • /start command
    • /image cat with sunglasses
    • Unsupported commands (e.g., /foo)

5. General Notes & Resources

Note Content Context or Link
Workflow demonstrates integration of Telegram bot with OpenAI GPT-4 for chat and DALL·E for image generation. Core use case for conversational AI and creative image generation.
Use of Telegram chat actions (typing, upload_photo) improves UX by indicating bot activity. Telegram Bot API documentation: https://core.telegram.org/bots/api#sendchataction
Command parsing is case-sensitive and literal; consider extending with regex or normalization for robustness. Potential improvement for production use.
Sticky notes provide clear documentation inside n8n editor for easier maintenance and onboarding. Best practice for complex workflows.
OpenAI API credentials must have chat and image generation permissions enabled. OpenAI API docs: https://platform.openai.com/docs/
Telegram bot must be configured with webhook URL matching n8n instance for triggers to work. Telegram Bot API webhook setup instructions.

This document provides a comprehensive understanding of the Telegram AI Chatbot workflow, enabling reproduction, extension, and troubleshooting with ease.

Reference in New Issue View Git Blame Copy Permalink