
ZerePy
ZerePy an open-source launch-pad for AI agents
Stars: 510

ZerePy is an open-source Python framework for deploying agents on X using OpenAI or Anthropic LLMs. It offers CLI interface, Twitter integration, and modular connection system. Users can fine-tune models for creative outputs and create agents with specific tasks. The tool requires Python 3.10+, Poetry 1.5+, and API keys for LLM, OpenAI, Anthropic, and X API.
README:
ZerePy is an open-source Python framework designed to let you deploy your own agents on X, powered by multiple LLMs.
ZerePy is built from a modularized version of the Zerebro backend. With ZerePy, you can launch your own agent with similar core functionality as Zerebro. For creative outputs, you'll need to fine-tune your own model.
- CLI interface for managing agents
- Modular connection system
- Blockchain integration
- Solana
- Ethereum
- GOAT (Great Onchain Agent Toolkit)
- Twitter/X
- Farcaster
- Echochambers
- OpenAI
- Anthropic
- EternalAI
- Ollama
- Hyperbolic
- Galadriel
- XAI (Grok)
The quickest way to start using ZerePy is to use our Replit template:
https://replit.com/@blormdev/ZerePy?v=1
- Fork the template (you will need you own Replit account)
- Click the run button on top
- Voila! your CLI should be ready to use, you can jump to the configuration section
System:
- Python 3.10 or higher
- Poetry 1.5 or higher
Environment Variables:
- LLM: make an account and grab an API key (at least one)
- OpenAI: https://platform.openai.com/api-keys
- Anthropic: https://console.anthropic.com/account/keys
- EternalAI: https://eternalai.oerg/api
- Hyperbolic: https://app.hyperbolic.xyz
- Galadriel: https://dashboard.galadriel.com
- Social (based on your needs):
- X API: https://developer.x.com/en/docs/authentication/oauth-1-0a/api-key-and-secret
- Farcaster: Warpcast recovery phrase
- Echochambers: API key and endpoint
- On-chain Integration:
- Solana: private key
- Ethereum: private keys
- First, install Poetry for dependency management if you haven't already:
Follow the steps here to use the official installation: https://python-poetry.org/docs/#installing-with-the-official-installer
- Clone the repository:
git clone https://github.com/blorm-network/ZerePy.git
- Go to the
zerepy
directory:
cd zerepy
- Install dependencies:
poetry install --no-root
This will create a virtual environment and install all required dependencies.
- Activate the virtual environment:
poetry shell
- Run the application:
poetry run python main.py
-
Configure your desired connections:
configure-connection twitter # For Twitter/X integration configure-connection openai # For OpenAI configure-connection anthropic # For Anthropic configure-connection farcaster # For Farcaster configure-connection eternalai # For EternalAI configure-connection solana # For Solana configure-connection goat # For Goat configure-connection galadriel # For Galadriel configure-connection ethereum # For Ethereum configure-connection discord # For Discord configure-connection ollama # For Ollama configure-connection xai # For Grok configure-connection allora # For Allora configure-connection hyperbolic # For Hyperbolic
-
Use
list-connections
to see all available connections and their status -
Load your agent (usually one is loaded by default, which can be set using the CLI or in agents/general.json):
load-agent example
-
Start your agent:
start
GOAT (Go Agent Tools) is a powerful plugin system that allows your agent to interact with various blockchain networks and protocols. Here's how to set it up:
- An RPC provider URL (e.g., from Infura, Alchemy, or your own node)
- A wallet private key for signing transactions
Install any of the additional GOAT plugins you want to use:
poetry add goat-sdk-plugin-erc20 # For ERC20 token interactions
poetry add goat-sdk-plugin-coingecko # For price data
-
Configure the GOAT connection using the CLI:
configure-connection goat
You'll be prompted to enter:
- RPC provider URL
- Wallet private key (will be stored securely in .env)
-
Add GOAT plugins configuration to your agent's JSON file:
{ "name": "YourAgent", "config": [ { "name": "goat", "plugins": [ { "name": "erc20", "args": { "tokens": [ "goat_plugins.erc20.token.PEPE", "goat_plugins.erc20.token.USDC" ] } }, { "name": "coingecko", "args": { "api_key": "YOUR_API_KEY" } } ] } ] }
Note that the order of plugins in the configuration doesn't matter, but each plugin must have a name
and args
field with the appropriate configuration options. You will have to check the documentation for each plugin to see what arguments are available.
Each plugin provides specific functionality:
- 1inch: Interact with 1inch DEX aggregator for best swap rates
- allora: Connect with Allora protocol
- coingecko: Get real-time price data for cryptocurrencies using the CoinGecko API
- dexscreener: Access DEX trading data and analytics
- erc20: Interact with ERC20 tokens (transfer, approve, check balances)
- farcaster: Interact with the Farcaster social protocol
- nansen: Access Nansen's on-chain analytics
- opensea: Interact with NFTs on OpenSea marketplace
- rugcheck: Analyze token contracts for potential security risks
- Many more to come...
Note: While these plugins are available in the GOAT SDK, you'll need to install them separately using Poetry and configure them in your agent's JSON file. Each plugin may require its own API keys or additional setup.
Each plugin has its own configuration options that can be specified in the agent's JSON file:
-
ERC20 Plugin:
{ "name": "erc20", "args": { "tokens": [ "goat_plugins.erc20.token.USDC", "goat_plugins.erc20.token.PEPE", "goat_plugins.erc20.token.DAI" ] } }
-
Coingecko Plugin:
{ "name": "coingecko", "args": { "api_key": "YOUR_COINGECKO_API_KEY" } }
- Interact with EVM chains through a unified interface
- Manage ERC20 tokens:
- Check token balances
- Transfer tokens
- Approve token spending
- Get token metadata (decimals, symbol, name)
- Access real-time cryptocurrency data:
- Get token prices
- Track market data
- Monitor price changes
- Extensible plugin system for future protocols
- Secure wallet management with private key storage
- Multi-chain support through configurable RPC endpoints
- Transfer SOL and SPL tokens
- Swap tokens using Jupiter
- Check token balances
- Stake SOL
- Monitor network TPS
- Query token information
- Request testnet/devnet funds
- Transfer ETH and ERC-20 Tokens
- Swap tokens using Kyberswao
- Check token balances
- Post tweets from prompts
- Read timeline with configurable count
- Reply to tweets in timeline
- Like tweets in timeline
- Post casts
- Reply to casts
- Like and requote casts
- Read timeline
- Get cast replies
- Post new messages to rooms
- Reply to messages based on room context
- Read room history
- Get room information and topics
- List channels for a server
- Read messages from a channel
- Read mentioned messages from a channel
- Post new messages to a channel
- Reply to messages in a channel
- React to a message in a channel
The secret to having a good output from the agent is to provide as much detail as possible in the configuration file. Craft a story and a context for the agent, and pick very good examples of tweets to include.
If you want to take it a step further, you can fine tune your own model: https://platform.openai.com/docs/guides/fine-tuning.
Create a new JSON file in the agents
directory following this structure:
{
"name": "ExampleAgent",
"bio": [
"You are ExampleAgent, the example agent created to showcase the capabilities of ZerePy.",
"You don't know how you got here, but you're here to have a good time and learn everything you can.",
"You are naturally curious, and ask a lot of questions."
],
"traits": ["Curious", "Creative", "Innovative", "Funny"],
"examples": ["This is an example tweet.", "This is another example tweet."],
"example_accounts" : ["X_username_to_use_for_tweet_examples"]
"loop_delay": 900,
"config": [
{
"name": "twitter",
"timeline_read_count": 10,
"own_tweet_replies_count": 2,
"tweet_interval": 5400
},
{
"name": "farcaster",
"timeline_read_count": 10,
"cast_interval": 60
},
{
"name": "openai",
"model": "gpt-3.5-turbo"
},
{
"name": "anthropic",
"model": "claude-3-5-sonnet-20241022"
},
{
"name": "eternalai",
"model": "NousResearch/Hermes-3-Llama-3.1-70B-FP8",
"chain_id": "45762"
},
{
"name": "solana",
"rpc": "https://api.mainnet-beta.solana.com"
},
{
"name": "ollama",
"base_url": "http://localhost:11434",
"model": "llama3.2"
},
{
"name": "hyperbolic",
"model": "meta-llama/Meta-Llama-3-70B-Instruct"
},
{
"name": "galadriel",
"model": "gpt-3.5-turbo"
},
{
"name": "discord",
"message_read_count": 10,
"message_emoji_name": "❤️",
"server_id": "1234567890"
},
{
"name": "ethereum",
"rpc": "placeholder_url.123"
}
],
"tasks": [
{ "name": "post-tweet", "weight": 1 },
{ "name": "reply-to-tweet", "weight": 1 },
{ "name": "like-tweet", "weight": 1 }
],
"use_time_based_weights": false,
"time_based_multipliers": {
"tweet_night_multiplier": 0.4,
"engagement_day_multiplier": 1.5
}
}
Use help
in the CLI to see all available commands. Key commands include:
-
list-agents
: Show available agents -
load-agent
: Load a specific agent -
agent-loop
: Start autonomous behavior -
agent-action
: Execute single action -
list-connections
: Show available connections -
list-actions
: Show available actions for a connection -
configure-connection
: Set up a new connection -
chat
: Start interactive chat with agent -
clear
: Clear the terminal screen
Made with ♥ @Blorm.xyz
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for ZerePy
Similar Open Source Tools

ZerePy
ZerePy is an open-source Python framework for deploying agents on X using OpenAI or Anthropic LLMs. It offers CLI interface, Twitter integration, and modular connection system. Users can fine-tune models for creative outputs and create agents with specific tasks. The tool requires Python 3.10+, Poetry 1.5+, and API keys for LLM, OpenAI, Anthropic, and X API.

pipecat-flows
Pipecat Flows is a framework designed for building structured conversations in AI applications. It allows users to create both predefined conversation paths and dynamically generated flows, handling state management and LLM interactions. The framework includes a Python module for building conversation flows and a visual editor for designing and exporting flow configurations. Pipecat Flows is suitable for scenarios such as customer service scripts, intake forms, personalized experiences, and complex decision trees.

firecrawl-mcp-server
Firecrawl MCP Server is a Model Context Protocol (MCP) server implementation that integrates with Firecrawl for web scraping capabilities. It supports features like scrape, crawl, search, extract, and batch scrape. It provides web scraping with JS rendering, URL discovery, web search with content extraction, automatic retries with exponential backoff, credit usage monitoring, comprehensive logging system, support for cloud and self-hosted FireCrawl instances, mobile/desktop viewport support, and smart content filtering with tag inclusion/exclusion. The server includes configurable parameters for retry behavior and credit usage monitoring, rate limiting and batch processing capabilities, and tools for scraping, batch scraping, checking batch status, searching, crawling, and extracting structured information from web pages.

VectorETL
VectorETL is a lightweight ETL framework designed to assist Data & AI engineers in processing data for AI applications quickly. It streamlines the conversion of diverse data sources into vector embeddings and storage in various vector databases. The framework supports multiple data sources, embedding models, and vector database targets, simplifying the creation and management of vector search systems for semantic search, recommendation systems, and other vector-based operations.

bot-on-anything
The 'bot-on-anything' repository allows developers to integrate various AI models into messaging applications, enabling the creation of intelligent chatbots. By configuring the connections between models and applications, developers can easily switch between multiple channels within a project. The architecture is highly scalable, allowing the reuse of algorithmic capabilities for each new application and model integration. Supported models include ChatGPT, GPT-3.0, New Bing, and Google Bard, while supported applications range from terminals and web platforms to messaging apps like WeChat, Telegram, QQ, and more. The repository provides detailed instructions for setting up the environment, configuring the models and channels, and running the chatbot for various tasks across different messaging platforms.

ruby-openai
Use the OpenAI API with Ruby! 🤖🩵 Stream text with GPT-4, transcribe and translate audio with Whisper, or create images with DALL·E... Hire me | 🎮 Ruby AI Builders Discord | 🐦 Twitter | 🧠 Anthropic Gem | 🚂 Midjourney Gem ## Table of Contents * Ruby OpenAI * Table of Contents * Installation * Bundler * Gem install * Usage * Quickstart * With Config * Custom timeout or base URI * Extra Headers per Client * Logging * Errors * Faraday middleware * Azure * Ollama * Counting Tokens * Models * Examples * Chat * Streaming Chat * Vision * JSON Mode * Functions * Edits * Embeddings * Batches * Files * Finetunes * Assistants * Threads and Messages * Runs * Runs involving function tools * Image Generation * DALL·E 2 * DALL·E 3 * Image Edit * Image Variations * Moderations * Whisper * Translate * Transcribe * Speech * Errors * Development * Release * Contributing * License * Code of Conduct

firecrawl
Firecrawl is an API service that takes a URL, crawls it, and converts it into clean markdown. It crawls all accessible subpages and provides clean markdown for each, without requiring a sitemap. The API is easy to use and can be self-hosted. It also integrates with Langchain and Llama Index. The Python SDK makes it easy to crawl and scrape websites in Python code.

hf-waitress
HF-Waitress is a powerful server application for deploying and interacting with HuggingFace Transformer models. It simplifies running open-source Large Language Models (LLMs) locally on-device, providing on-the-fly quantization via BitsAndBytes, HQQ, and Quanto. It requires no manual model downloads, offers concurrency, streaming responses, and supports various hardware and platforms. The server uses a `config.json` file for easy configuration management and provides detailed error handling and logging.

AICentral
AI Central is a powerful tool designed to take control of your AI services with minimal overhead. It is built on Asp.Net Core and dotnet 8, offering fast web-server performance. The tool enables advanced Azure APIm scenarios, PII stripping logging to Cosmos DB, token metrics through Open Telemetry, and intelligent routing features. AI Central supports various endpoint selection strategies, proxying asynchronous requests, custom OAuth2 authorization, circuit breakers, rate limiting, and extensibility through plugins. It provides an extensibility model for easy plugin development and offers enriched telemetry and logging capabilities for monitoring and insights.

promptic
Promptic is a tool designed for LLM app development, providing a productive and pythonic way to build LLM applications. It leverages LiteLLM, allowing flexibility to switch LLM providers easily. Promptic focuses on building features by providing type-safe structured outputs, easy-to-build agents, streaming support, automatic prompt caching, and built-in conversation memory.

sparrow
Sparrow is an innovative open-source solution for efficient data extraction and processing from various documents and images. It seamlessly handles forms, invoices, receipts, and other unstructured data sources. Sparrow stands out with its modular architecture, offering independent services and pipelines all optimized for robust performance. One of the critical functionalities of Sparrow - pluggable architecture. You can easily integrate and run data extraction pipelines using tools and frameworks like LlamaIndex, Haystack, or Unstructured. Sparrow enables local LLM data extraction pipelines through Ollama or Apple MLX. With Sparrow solution you get API, which helps to process and transform your data into structured output, ready to be integrated with custom workflows. Sparrow Agents - with Sparrow you can build independent LLM agents, and use API to invoke them from your system. **List of available agents:** * **llamaindex** - RAG pipeline with LlamaIndex for PDF processing * **vllamaindex** - RAG pipeline with LLamaIndex multimodal for image processing * **vprocessor** - RAG pipeline with OCR and LlamaIndex for image processing * **haystack** - RAG pipeline with Haystack for PDF processing * **fcall** - Function call pipeline * **unstructured-light** - RAG pipeline with Unstructured and LangChain, supports PDF and image processing * **unstructured** - RAG pipeline with Weaviate vector DB query, Unstructured and LangChain, supports PDF and image processing * **instructor** - RAG pipeline with Unstructured and Instructor libraries, supports PDF and image processing. Works great for JSON response generation

deep-searcher
DeepSearcher is a tool that combines reasoning LLMs and Vector Databases to perform search, evaluation, and reasoning based on private data. It is suitable for enterprise knowledge management, intelligent Q&A systems, and information retrieval scenarios. The tool maximizes the utilization of enterprise internal data while ensuring data security, supports multiple embedding models, and provides support for multiple LLMs for intelligent Q&A and content generation. It also includes features like private data search, vector database management, and document loading with web crawling capabilities under development.

llm-web-api
LLM Web API is a tool that provides a web page to API interface for ChatGPT, allowing users to bypass Cloudflare challenges, switch models, and dynamically display supported models. It uses Playwright to control a fingerprint browser, simulating user operations to send requests to the OpenAI website and converting the responses into API interfaces. The API currently supports the OpenAI-compatible /v1/chat/completions API, accessible using OpenAI or other compatible clients.

scylla
Scylla is an intelligent proxy pool tool designed for humanities, enabling users to extract content from the internet and build their own Large Language Models in the AI era. It features automatic proxy IP crawling and validation, an easy-to-use JSON API, a simple web-based user interface, HTTP forward proxy server, Scrapy and requests integration, and headless browser crawling. Users can start using Scylla with just one command, making it a versatile tool for various web scraping and content extraction tasks.

chat-ui
A chat interface using open source models, eg OpenAssistant or Llama. It is a SvelteKit app and it powers the HuggingChat app on hf.co/chat.

redcache-ai
RedCache-ai is a memory framework designed for Large Language Models and Agents. It provides a dynamic memory framework for developers to build various applications, from AI-powered dating apps to healthcare diagnostics platforms. Users can store, retrieve, search, update, and delete memories using RedCache-ai. The tool also supports integration with OpenAI for enhancing memories. RedCache-ai aims to expand its functionality by integrating with more LLM providers, adding support for AI Agents, and providing a hosted version.
For similar tasks

ZerePy
ZerePy is an open-source Python framework for deploying agents on X using OpenAI or Anthropic LLMs. It offers CLI interface, Twitter integration, and modular connection system. Users can fine-tune models for creative outputs and create agents with specific tasks. The tool requires Python 3.10+, Poetry 1.5+, and API keys for LLM, OpenAI, Anthropic, and X API.
For similar jobs

sweep
Sweep is an AI junior developer that turns bugs and feature requests into code changes. It automatically handles developer experience improvements like adding type hints and improving test coverage.

teams-ai
The Teams AI Library is a software development kit (SDK) that helps developers create bots that can interact with Teams and Microsoft 365 applications. It is built on top of the Bot Framework SDK and simplifies the process of developing bots that interact with Teams' artificial intelligence capabilities. The SDK is available for JavaScript/TypeScript, .NET, and Python.

ai-guide
This guide is dedicated to Large Language Models (LLMs) that you can run on your home computer. It assumes your PC is a lower-end, non-gaming setup.

classifai
Supercharge WordPress Content Workflows and Engagement with Artificial Intelligence. Tap into leading cloud-based services like OpenAI, Microsoft Azure AI, Google Gemini and IBM Watson to augment your WordPress-powered websites. Publish content faster while improving SEO performance and increasing audience engagement. ClassifAI integrates Artificial Intelligence and Machine Learning technologies to lighten your workload and eliminate tedious tasks, giving you more time to create original content that matters.

chatbot-ui
Chatbot UI is an open-source AI chat app that allows users to create and deploy their own AI chatbots. It is easy to use and can be customized to fit any need. Chatbot UI is perfect for businesses, developers, and anyone who wants to create a chatbot.

BricksLLM
BricksLLM is a cloud native AI gateway written in Go. Currently, it provides native support for OpenAI, Anthropic, Azure OpenAI and vLLM. BricksLLM aims to provide enterprise level infrastructure that can power any LLM production use cases. Here are some use cases for BricksLLM: * Set LLM usage limits for users on different pricing tiers * Track LLM usage on a per user and per organization basis * Block or redact requests containing PIIs * Improve LLM reliability with failovers, retries and caching * Distribute API keys with rate limits and cost limits for internal development/production use cases * Distribute API keys with rate limits and cost limits for students

uAgents
uAgents is a Python library developed by Fetch.ai that allows for the creation of autonomous AI agents. These agents can perform various tasks on a schedule or take action on various events. uAgents are easy to create and manage, and they are connected to a fast-growing network of other uAgents. They are also secure, with cryptographically secured messages and wallets.

griptape
Griptape is a modular Python framework for building AI-powered applications that securely connect to your enterprise data and APIs. It offers developers the ability to maintain control and flexibility at every step. Griptape's core components include Structures (Agents, Pipelines, and Workflows), Tasks, Tools, Memory (Conversation Memory, Task Memory, and Meta Memory), Drivers (Prompt and Embedding Drivers, Vector Store Drivers, Image Generation Drivers, Image Query Drivers, SQL Drivers, Web Scraper Drivers, and Conversation Memory Drivers), Engines (Query Engines, Extraction Engines, Summary Engines, Image Generation Engines, and Image Query Engines), and additional components (Rulesets, Loaders, Artifacts, Chunkers, and Tokenizers). Griptape enables developers to create AI-powered applications with ease and efficiency.