Introduction

What if you could lend, borrow, and interact with DeFi protocols — just by chatting with an AI on Telegram? 

That’s exactly what we explored in this hands-on workshop!

Learn how to build a DeFi-focused AI agent that interacts with lending and borrowing protocols on the Metis using Alith SDK.

In this workshop, we demonstrated building an AI-powered Telegram bot that can execute DeFi actions such as lending and borrowing via natural language, all while utilizing Alith’s agent framework.

Workshop Recording: Watch it on YouTube

Source Code: DEFI_Agent GitHub Repository

Prefer a written guide instead of watching the full recording? This blog and repo are perfect for you!

Why Build a DeFi AI Agent?

• DeFi can be complex — interacting with smart contracts isn’t always user-friendly.
  
• AI agents bridge that gap, making DeFi actions accessible through simple human conversations.
  
• Metis offers an efficient Layer 2 environment with low fees — perfect for experimenting with AI + DeFi automation.
  

By the end of this tutorial, you’ll have your own agent that lends and borrows assets on Metis just by chatting!

High-Level Architecture

Here’s what we’re building:

Natural Language → Blockchain Transactions — in a few simple steps!

Prerequisites

Before you begin, ensure you have:

• Python 3.11+
  
• Node.js (optional, for bot deployment)
  
• MetaMask Wallet (for Web3 interactions)
  
• Basic understanding of DeFi and AI agent concepts
  
• Deepseek/OpenAI API Key (for LLM processing)
  
• Telegram account (to create a bot)
  
• Basic familiarity with smart contracts and blockchain explorers
  

Installation

1. Clone the Repository

git clone https://github.com/Gmetisl2/DEFI_Agent.git
cd DEFI_Agent

2. Install Python (Prerequisite)

Ensure that Python 3.x is installed on your system.

If not, download it from python.org.

Note: Python 3.x is required for compatibility.

3. Create and Activate a Virtual Environment

python -m venv venv
source venv/bin/activate   # On Linux/Mac
venv\Scripts\activate  # On Windows

4. Install Dependencies

pip install -r requirements.txt

5. Configure Environment Variables

Create a .env file in the root directory:

PRIVATE_KEY=your_wallet_private_key
PUBLIC_ADDRESS=your_wallet_address
ALCHEMY_RPC_URL=https://andromeda.metis.io/?owner=1088
TELEGRAM_TOKEN=your_telegram_bot_token
LLM_API_KEY=your_deepseek_or_openai_api_key

Project Structure

project-root/
├── assets/              # ABI files for token contracts
├── defi_integration.py  # Web3 transaction handling (lending, borrowing, repaying)
├── agent_runner.py      # Main file to run the AI Agent
├── utils.py             # Helper utilities
├── requirements.txt     # Python dependencies
├── .env                 # Environment variables
└── README.md            # Project documentation

Usage

Running the Project

1. Activate your virtual environment:

source venv/bin/activate

2. Run the AI Agent:

python Agent.py

The bot will:

• Connect to your specified wallet
  
• Listen to Telegram chat inputs
  
• Process instructions like lend 1 USDC or borrow 1 USDC
  

Execute transactions on-chain!

Example Interaction

In Telegram:

 You: “Lend 1 USDC”

 Bot: “Transaction approved. 1 USDC lent successfully.”

 You: “Borrow 1 USDC”

 Bot: “Transaction approved. 1 USDC borrowed against your collateral.”

Testing

At this stage, manual testing is recommended:

• Clone the repo
  
• Setup .env
  
• Run the bot locally
  
• Send commands via Telegram
  
• Monitor console logs for transaction hashes
  

Coming Soon:

• Unit tests for smart contract interaction
  
• Simulation scripts for multi-agent conversation scenarios
  

Troubleshooting

Common Issues

• Transaction Failed: Ensure your wallet has sufficient funds (MATIC/METIS for gas fees).
  
• Bot Not Responding: Check your Telegram bot token and ensure your environment is active.
  
• LLM Errors: Verify your Deepseek/OpenAI API Key is correct and has usage quota.
  

Debugging Tips

• Use print() statements to debug agent actions.
  
• Monitor on-chain transactions via Metis Andromeda explorer.
  

Make sure environment variables are correctly loaded.

Resources

• Alith SDK Documentation 
• Metis Documentation
• Telegram BotFather Guide

Community and Support

• Metis Discord
• Elith Devs Telegram 

Follow us on X for more updates: @MetisDevs

Feel free to join our developer community, collaborate, and ask questions!

Contributing

We welcome contributions! Please:

• Fork the repository
  
• Create a feature branch
  
• Submit a pull request
  
• Follow clean coding standards and add proper documentation
  

Contribution Guidelines

• Write modular, commented code
  
• Include small unit tests (where feasible)
  

Document any new functions or integrations

‍

License

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

Conclusion

By completing this project, you learned how to build an AI-driven DeFi agent that interacts with blockchain protocols using natural language prompts over Telegram.

You now have a working base to extend: add more DeFi integrations, improve AI strategies, or create your own trading bot!

Want to level up? Check out the Alith Agent Advanced Tutorials.