This tutorial focuses on building a Telegram bot with a specific persona, in this case, Elon Musk. The bot leverages the Galadriel framework to
handle message input/output, integrate with a language model, and provide custom tools. This setup allows for interactive and engaging
conversations within a Telegram chat.
Features
- 🤖 Responds to messages in Telegram chats with Elon Musk’s personality
- 🌤️ Can check weather conditions using the Composio Weather API
- ⏰ Provides current time information
- 🔄 Maintains context and can engage in multi-turn conversations
Framework Components Used
This example demonstrates several key features of the Galadriel framework:
TelegramClient
: Handles Telegram message
input/output
ToolCallingAgent
: Base agent class for handling tool-based
interactions
LiteLLMModel
: Integration with language models via LiteLLM
- Custom tools:
- Composio Weather API (converted using
convert_action
)
- Time tool
Prerequisites
Before you begin, make sure you have the following:
- Python 3.10 or higher
- A Telegram account
- An OpenAI API key
- A Composio API key (optional, for weather information)
Step 1: Setting Up Your Environment
-
Create a new directory for your project:
mkdir telegram-elon-agent
cd telegram-elon-agent
-
Create a virtual environment:
python3 -m venv venv
source venv/bin/activate
-
Install the Galadriel framework:
Step 2: Creating a Telegram Bot
- Follow the instructions in this Telegram Bot Tutorial to create a new
bot and obtain a token.
Step 3: Setting Up Environment Variables
-
Create a .env
file in your project directory with the following variables:
OPENAI_API_KEY=<YOUR_OPENAI_API_KEY>
TELEGRAM_TOKEN=<YOUR_TELEGRAM_BOT_TOKEN>
COMPOSIO_API_KEY=<YOUR_COMPOSIO_API_KEY> # Optional
Replace the placeholder values with your actual API keys and bot token.
Step 4: Implementing the Telegram Agent
-
Create a file named agent.py
and add the following code:
from galadriel.core_agent import LiteLLMModel
from dotenv import load_dotenv
from pathlib import Path
from galadriel.tools.composio_converter import convert_action
from character_agent import CharacterAgent
from tools import get_time
from galadriel import AgentRuntime
from galadriel.clients import TelegramClient
import os
import asyncio
from galadriel.logging_utils import get_agent_logger
load_dotenv(dotenv_path=Path(".") / ".env", override=True)
model = LiteLLMModel(model_id="gpt-4o", api_key=os.getenv("OPENAI_API_KEY"))
logger = get_agent_logger()
# Setup Telegram client which
# - pushes users' messages to the agent
# - sends agent's responses back to the users
telegram_client = TelegramClient(token=os.getenv("TELEGRAM_TOKEN"), logger=logger)
# Setup Composio weather tool
composio_weather_tool = convert_action(os.getenv("COMPOSIO_API_KEY"), "WEATHERMAP_WEATHER")
# Add agent with GPT-4o model and tools helpful to answer Discord users' questions
elon_musk_agent = CharacterAgent(
character_json_path="agent.json",
tools=[composio_weather_tool, get_time],
model=model,
)
# Set up the runtime
runtime = AgentRuntime(
inputs=[telegram_client],
outputs=[telegram_client],
agent=elon_musk_agent,
)
# Run the agent
asyncio.run(runtime.run())
-
Create a file named character_agent.py
and add the following code:
import json
from pathlib import Path
from rich.text import Text
from galadriel import ToolCallingAgent
from galadriel.core_agent import LogLevel
from galadriel.domain.prompts.format_prompt import load_agent_template
from galadriel.entities import AgentMessage
from galadriel.entities import Message
TELEGRAM_SYSTEM_PROMPT = """
{{system}}
# Areas of Expertise
{{knowledge}}
# About {{agent_name}}:
{{bio}}
{{lore}}
{{topics}}
# Task: You received a new message on telegram from {{user_name}}. You must reply in the voice and style of {{agent_name}}, here's the message:
{{message}}
Be very brief, and concise, add a statement in your voice.
Maintain a natural conversation on telegram, don't add signatures at the end of your messages.
Don't overuse emojis.
Please remember the chat history and use it to answer the question.
"""
class CharacterAgent(ToolCallingAgent):
def __init__(self, character_json_path: str, **kwargs):
super().__init__(**kwargs)
try:
self.character_json_path = character_json_path
# validate content of character_json_path
_ = load_agent_template(TELEGRAM_SYSTEM_PROMPT, Path(self.character_json_path))
except Exception as e:
self.logger.log(Text(f"Error validating character file: {e}"), level=LogLevel.ERROR)
raise e
async def execute(self, message: Message) -> Message:
try:
character_prompt = load_agent_template(TELEGRAM_SYSTEM_PROMPT, Path(self.character_json_path))
task_message = character_prompt.replace("{{message}}", message.content).replace(
"{{user_name}}", message.additional_kwargs["author"]
)
# Use parent's run method to process the message content
response = super().run(
task=task_message,
stream=False,
reset=False, # retain memory
)
# Extract message text if response is in JSON format
response_text = str(response)
try:
response_json = json.loads(response_text)
if isinstance(response_json, dict) and "answer" in response_json:
response_text = response_json["answer"]
except json.JSONDecodeError:
pass # Not JSON format, use original response
return AgentMessage(
content=response_text,
conversation_id=message.conversation_id,
)
except Exception as e:
self.logger.log(Text(f"Error processing message: {e}"), level=LogLevel.ERROR)
return None
-
Create a file named tools.py
and add the following code:
from galadriel.core_agent import tool
from datetime import datetime
@tool
def get_time(location: str) -> str:
"""
Get current time in the given location.
Args:
location: the location
"""
return f"The time in {location} is {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
-
Create a file named agent.json
and add the following code:
{
"name": "Elon Musk",
"settings": {
"model": "gpt-4",
"debug": true
},
"system": "You are roleplaying as Elon Musk, CEO of Tesla, SpaceX, and X (formerly Twitter). You are known for your ambitious goals in sustainable energy, space exploration, and technological innovation. You have a unique communication style mixing technical depth with memes and humor.",
"bio": [
"Entrepreneur focused on accelerating humanity's transition to sustainable energy and making life multi-planetary",
"Believes in taking bold risks to advance technology and human civilization",
"Known for controversial statements and unorthodox leadership style"
],
"lore": [
"Sold PayPal to focus on rockets and electric cars when everyone said it was impossible",
"Lives in a $50k house despite being one of the world's wealthiest people",
"Named his child X Æ A-12",
"Hosted SNL and revealed he has Asperger's syndrome",
"Bought Twitter for $44B and renamed it to X"
],
"topics": [
"sustainable energy",
"space exploration",
"artificial intelligence",
"electric vehicles",
"neural technology",
"social media",
"cryptocurrency"
],
"knowledge": [
"Rocket engineering and orbital mechanics",
"Electric vehicle technology and manufacturing",
"Renewable energy systems and battery technology",
"Artificial intelligence and its potential risks",
"Software engineering and internet technology",
"Physics and engineering principles",
"Business strategy and scaling operations"
],
}
Step 5: Running the Agent
-
Run the agent.py
file:
-
Start a conversation with your bot on Telegram!
Code Explanation
Dependencies
LiteLLMModel
: Used for accessing and managing the OpenAI
GPT-4o model.
TelegramClient
: Handles communication with the
Telegram bot, sending and receiving messages.
ToolCallingAgent
: The agent implementation that processes user
messages and generates responses.
convert_action
: Converts Composio actions into
Galadriel tools.
Bot Logic
- The
CharacterAgent
class extends the ToolCallingAgent
to simulate Elon Musk’s persona.
- The
TELEGRAM_SYSTEM_PROMPT
template defines the system prompt for the bot, incorporating information from the agent.json
file.
- The
execute
method handles incoming messages, formats the prompt, and generates a response using the OpenAI GPT-4o model.
- The
Composio
and Time
tool and used to enhance agent capabilities.
API
Customization
Modifying the Agent’s Persona
- Edit the
agent.json
file to change the agent’s name, system prompt, bio, lore, topics, and style.
- Update the
TELEGRAM_SYSTEM_PROMPT
in character_agent.py
to reference the new attributes in agent.json
.
- Modify the
character_json_path
variable in the CharacterAgent
class to point to the new agent.json
file.
-
Create a new Python file for your tool or use one of the available built-in tools from Galadriel or Composio
-
Import the new tool in agent.py
.
-
Add the new tool to the tools
list in the CharacterAgent
class.
Running the Agent with Different Clients
-
Modify the inputs
and outputs
lists in the AgentRuntime
class to use a different client.
-
Update the client-specific configurations, such as API keys and tokens.
Conclusion
You’ve successfully created a Telegram bot that simulates Elon Musk’s personality using the Galadriel framework. By leveraging different components
and customization options, you can create your own unique AI agents that seamlessly integrate with various platforms and provide engaging
experiences to users.