twitter-automation-ai

twitter-automation-ai

Advanced Python-based Twitter (X.com) automation framework using Selenium and LLMs (OpenAI, Gemini) for multi-account scraping, posting, engagement, and content analysis. Modular and configurable.

Stars: 56

Visit
screenshot

Advanced Twitter Automation AI is a modular Python-based framework for automating Twitter at scale. It supports multiple accounts, robust Selenium automation with optional undetected Chrome + stealth, per-account proxies and rotation, structured LLM generation/analysis, community posting, and per-account metrics/logs. The tool allows seamless management and automation of multiple Twitter accounts, content scraping, publishing, LLM integration for generating and analyzing tweet content, engagement automation, configurable automation, browser automation using Selenium, modular design for easy extension, comprehensive logging, community posting, stealth mode for reduced fingerprinting, per-account proxies, LLM structured prompts, and per-account JSON summaries and event logs for observability.

README:

Advanced Twitter Automation AI

License: MIT Python Version Issues Forks Stars Contributors

Advanced Twitter Automation AI is a modular Python-based framework for automating X (Twitter) at scale. It supports multiple accounts, robust Selenium automation (with optional undetected Chrome + stealth), per‑account proxies and rotation, structured LLM generation/analysis (OpenAI, Azure OpenAI, Gemini), community posting, and per‑account metrics/logs.

Table of Contents

Features

  • Multi-Account Management: Seamlessly manage and automate actions for multiple Twitter accounts.
  • Content Scraping:
    • Scrape tweets based on keywords, user profiles, and news/research sites.
    • Extract tweet content, user information, and engagement metrics.
  • Content Publishing:
    • Post new tweets, including text and media.
    • Reply to tweets based on various triggers.
    • Repost (retweet) content from competitor profiles or based on engagement metrics.
  • LLM Integration:
    • Utilize OpenAI (GPT models) and Google Gemini for:
      • Generating tweet content and replies.
      • Analyzing tweet threads and sentiment.
      • Summarizing articles for posting.
    • Flexible LLM preference settings at global and per-account levels.
  • Engagement Automation:
    • Engage with tweets through likes, replies, and reposts.
    • Analyze competitor activity and engage strategically.
  • Configurable Automation:
    • Fine-grained control over automation parameters via JSON configuration files.
    • Per-account overrides for keywords, target profiles, LLM settings, and action behaviors.
  • Browser Automation: Uses Selenium for interacting with Twitter, handling dynamic content and complex UI elements.
  • Modular Design: Easily extendable with new features and functionalities.
  • Logging: Comprehensive logging for monitoring and debugging.
  • Community Posting: Switch audience and post into configured communities (by ID or name).
  • Stealth Mode (Chrome): Optional undetected-chromedriver + selenium-stealth to reduce fingerprinting.
  • Proxies: Per-account proxies, named proxy pools, and rotation strategies (hash/round-robin) with env interpolation.
  • LLM Structured Prompts: Strict JSON prompting with few-shots, system prompts, and robust extraction.
  • Metrics: Per-account JSON summaries and JSONL event logs for observability.

Technology Stack

  • Programming Language: Python 3.9+
  • Browser Automation: Selenium, WebDriver Manager
  • HTTP Requests: Requests
  • Data Validation: Pydantic
  • LLM Integration: Langchain (for Google GenAI), OpenAI SDK
  • Stealth: undetected-chromedriver, selenium-stealth (optional)
  • Configuration: JSON, python-dotenv
  • Web Interaction: Fake Headers (for mimicking browser headers)

Project Structure

The project is organized as follows:

twitter-automation-ai/
├── config/
│   ├── accounts.json       # Configuration for multiple Twitter accounts
│   └── settings.json       # Global settings (API keys, automation parameters)
├── src/
│   ├── core/               # Core modules (browser, LLM, config)
│   │   ├── browser_manager.py
│   │   ├── config_loader.py
│   │   └── llm_service.py
│   ├── features/           # Modules for Twitter features (scraper, publisher, etc.)
│   │   ├── scraper.py
│   │   ├── publisher.py
│   │   └── engagement.py
│   ├── utils/              # Utility modules (logger, file handler, etc.)
│   │   ├── logger.py
│   │   ├── file_handler.py
│   │   ├── progress.py
│   │   └── scroller.py
│   ├── data_models.py      # Pydantic models for data structures
│   ├── main.py             # Main orchestrator script
│   └── __init__.py
├── .env                    # Environment variables (optional, for API keys)
├── requirements.txt        # Python dependencies
├── .gitignore              # Specifies intentionally untracked files
├── LICENSE                 # Project license
├── CODE_OF_CONDUCT.md      # Contributor Code of Conduct
├── CONTRIBUTING.md         # Guidelines for contributing
└── README.md               # This file

Prerequisites

  • Python 3.9 or higher.
  • A modern web browser (e.g., Chrome, Firefox) compatible with Selenium.

Setup and Configuration

Follow these steps to set up and run the project:

Presets (Beginner-Friendly)

Quick-start templates are available in presets/.

  • Settings presets: presets/settings/*.json (defaults, Chrome undetected, proxies hash/round-robin)
  • Accounts presets: presets/accounts/*.json (growth, brand_safe, replies_first, engagement_light, community_posting)
  • How to apply:
    • cp presets/settings/beginner-chrome-undetected.json config/settings.json
    • cp presets/accounts/growth.json config/accounts.json
    • Edit placeholders for API keys, cookie paths, and community IDs.
    • See presets/README.md and data/README.md (dummy cookies/proxies).

1. Clone Repository

git clone https://github.com/ihuzaifashoukat/twitter-automation-ai
cd twitter-automation-ai

2. Create Virtual Environment

It's highly recommended to use a virtual environment:

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

3. Install Dependencies

Install the required Python packages:

pip install -r requirements.txt

4. Configure Accounts (config/accounts.json)

This file manages individual Twitter account configurations. It should be an array of account objects.

  • Key Fields per Account:

    • account_id: A unique identifier for the account.
    • is_active: Boolean, set to true to enable automation for this account.
    • cookie_file_path: Path to a JSON file containing cookies for the account (e.g., config/my_account_cookies.json).
    • cookies: Alternatively, an array of cookie objects can be provided directly.
    • proxy (optional): Per-account proxy URL. Examples: http://user:pass@host:port, socks5://host:port.
    • post_to_community (optional): When true, switch the audience to a community before posting.
    • community_id (optional): Community ID used to select the audience (preferred).
    • community_name (optional): Fallback visible name in the audience picker if ID selection fails.
    • Overrides: You can specify per-account overrides for various settings like target_keywords_override, competitor_profiles_override, llm_settings_override, and action_config_override. If an override is not present, the global defaults from config/settings.json will be used.

  • Example config/accounts.json entry:

    // Minimal example: ONLY add the community fields you need; keep your existing structure as-is.
// Below shows adding community + (optional) proxy to one of your existing account objects:
{
  "account_id": "your_existing_account_id",
  "is_active": true,
  "cookie_file_path": "config/your_existing_cookie_file.json",
  // ... all your existing fields remain unchanged ...
  "proxy": "http://127.0.0.1:8888",            // optional
  "post_to_community": true,                    // optional
  "community_id": "1737236915810627584",      // preferred when known
  "community_name": "One Piece"                // fallback by visible name
}

    (Refer to the example in the original README section for a more detailed structure if needed, or adapt based on current data_models.py.)

  • Obtaining Cookies: Use browser developer tools (e.g., "EditThisCookie" extension) to export cookies for x.com after logging in. Save them as a JSON array of cookie objects if using cookie_file_path.

  • Per-Account Proxy: If set, the proxy overrides the global browser_settings.proxy for that account. Chrome uses --proxy-server; Firefox is configured via profile preferences (proxy auth prompts are not handled automatically).

  • Community Posting: When post_to_community is true, the publisher clicks the "Choose audience" button in the composer and selects your community using community_id (preferred) or community_name as a fallback, then posts.

  • Important: We do not require changing your existing accounts.json structure. Simply add the optional fields (post_to_community, community_id, community_name, and/or proxy) to the appropriate account objects.

  • For rewrite-based posting to communities or personal profiles, ensure each account has competitor sources configured via competitor_profiles (or competitor_profiles_override in your current structure). The scraper uses these as input for rewriting and posting.

5. Configure Global Settings (config/settings.json)

This file contains global configurations for the application.

  • Key Sections:
    • api_keys: Store API keys for LLM services (e.g., openai_api_key, gemini_api_key).
    • twitter_automation:
      • action_config: Default behaviors for automation actions (e.g., max_posts_per_run, min_likes_for_repost).
      • response_interval_seconds: Default delay between actions.
      • media_directory: Path to store downloaded media.
      • analysis_config: Enable/disable relevance filters per pipeline and thresholds.
      • enable_relevance_filter.competitor_reposts (bool), thresholds.competitor_reposts_min (0–1)
      • enable_relevance_filter.likes (bool), thresholds.likes_min (0–1)
      • engagement_decision: If enabled: true, automatically chooses between repost/retweet/quote/like based on relevance and sentiment.
      • use_sentiment: include sentiment in decision
      • thresholds.quote_min|retweet_min|repost_min: relevance cutoffs (0–1)
    • logging: Configuration for the logger.
  • browser_settings: Settings for Selenium WebDriver (e.g., headless mode).
    • type: chrome or firefox. For best anti-detection, use Chrome with use_undetected_chromedriver.
    • use_undetected_chromedriver (Chrome only): When true, uses undetected-chromedriver for stealthier automation.
    • enable_stealth (Chrome only): When true and selenium-stealth is installed, applies additional anti-detection tweaks.
    • user_agent_generation: random or custom with custom_user_agent string.
    • proxy: Global proxy (can be overridden per account).
    • driver_options: Extra Chrome/Firefox CLI options.
    • page_load_timeout_seconds, script_timeout_seconds, window_size.

LLM prompt engineering

  • LLM prompts now use stronger, schema-first instructions for structured JSON with optional few-shot examples and hard character limits.
  • LLMService.generate_text accepts an optional system_prompt and messages for OpenAI/Azure; Gemini concatenates system+user.
  • LLMService.generate_structured adds few_shots, system_prompt, and hard_character_limit to guide safer, parsable outputs.
    • proxy_pools: Named pools for per-account proxies. Use "pool:<name>" in account proxy to select from a pool.
    • proxy_pool_strategy: hash (stable per-account) or round_robin (rotates across runs/accounts).
    • proxy_pool_state_file: Persist file for round-robin counters (default data/proxy_pools_state.json).
  • Important Note: Content source lists like target_keywords, competitor_profiles, etc., are primarily managed per-account in config/accounts.json. The global action_config in settings.json defines default how actions run, which can be overridden per account.

6. Environment Variables (.env) (Optional)

For sensitive data like API keys, you can use a .env file in the project root. python-dotenv is included in requirements.txt to load these variables.

  • Create a .env file: 
    OPENAI_API_KEY="your_openai_api_key"
GEMINI_API_KEY="your_gemini_api_key"
# Add other sensitive variables as needed
    The application is designed to prioritize environment variables for API keys if available.

Running the Application

Execute the main orchestrator script from the project root:

python src/main.py

The orchestrator will iterate through active accounts in config/accounts.json and perform actions based on their respective configurations and global settings.

Community Posting

To post into a community instead of your public timeline, set the following on the account object in config/accounts.json:

  • post_to_community: true
  • Provide at least one of:
    • community_id: preferred (appears in URLs like /i/communities/<id>)
    • community_name: fallback by the visible label in the audience picker

How selection works:

  • The app opens the “Choose audience” control, locates the audience menu container (dialog or data-testid="HoverCard"), and attempts to click your community.
  • It scrolls the virtualized list to reveal off-screen items and uses JS-click fallbacks to avoid overlay interception.
  • After selection, it posts using the chosen audience.

If it fails to select your community:

  • Verify the account has joined the community and it appears under “My Communities”.
  • Provide a DOM snapshot from the audience menu in a GitHub issue so selectors can be tuned.

Keyword Engagement

Controls live under twitter_automation.action_config (globally) and per-account action_config_override:

  • Replies: enable_keyword_replies, max_replies_per_keyword_run, optional recency reply_only_to_recent_tweets_hours.
  • Likes: enable_liking_tweets, max_likes_per_run, like_tweets_from_keywords (defaults to account target_keywords when omitted).
  • Retweets (new): enable_keyword_retweets, max_retweets_per_keyword_run.

Relevance filters (optional):

  • enable_relevance_filter_keyword_replies, relevance_threshold_keyword_replies
  • enable_relevance_filter_likes, relevance_threshold_likes

Troubleshooting

  • ElementClickInterceptedException or “not clickable”:

    • The app automatically scrolls into view, waits for the composer mask to disappear, and uses JS-click or Ctrl+Enter fallbacks.
    • If it persists, consider adding small delays or switching to Chrome (browser_settings.type: "chrome").

  • Community not selected:

    • Ensure post_to_community: true and set community_id (best) or community_name.
    • The audience list is virtualized; the app scrolls within the menu to reveal items. If your UI differs, open an issue with a DOM snippet.

  • WebDriver downloads blocked or offline:

    • The app prefers local drivers (chromedriver, geckodriver) if found in PATH or via chrome_driver_path/gecko_driver_path. Install via your OS package manager or ensure they’re in PATH.

  • Gemini errors (429/500):

    • Use gemini-1.5-flash-latest, reduce calls, or configure OpenAI/Azure.

LLM Prompting

  • Structured analysis and generation use strict schema-first prompts with robust JSON extraction. OpenAI JSON mode is attempted when available.
  • Internally supports system prompts and few-shot examples for more controllable outputs.
  • Content generation for posts composes final text (with optional hashtags) within 280 chars.

Browser & Stealth

  • Chrome: set browser_settings.type to "chrome" and enable use_undetected_chromedriver. Optional enable_stealth applies extra anti-detection tweaks.
  • Firefox: standard Selenium with proxy prefs; auth prompts are not auto-handled.
  • Headless: Chrome uses --headless=new for better parity. User-Agent randomized by default.

Proxies

  • Per-account proxy overrides global. Use "pool:<name>" to select from browser_settings.proxy_pools.
  • Rotation strategies: hash (stable per-account) or round_robin (uses data/proxy_pools_state.json).
  • Env interpolation: ${ENV_VAR} inside proxy strings is expanded at runtime.

Cookies

  • Point cookie_file_path to a JSON array of cookies for x.com. The app navigates to browser_settings.cookie_domain_url before injecting cookies.
  • Example file: data/cookies/dummy_cookies_example.json.

Metrics & Logs

  • Summary per account: data/metrics/<account_id>.json (counters for posts, replies, retweets, quote_tweets, likes, errors; last run timestamps)
  • Structured events per account: logs/accounts/<account_id>.jsonl (JSON lines of each action attempt with metadata)

Configuration Reference

See docs/CONFIG_REFERENCE.md for a concise schema of config/settings.json and config/accounts.json, including per-account action_config_override fields and decision thresholds.

Development Notes

  • Logging: Detailed logs are output to the console. Configuration is in config/settings.json and managed by src/utils/logger.py.
  • Selenium Selectors: Twitter's (X.com) UI is subject to change. XPath and CSS selectors in src/features/scraper.py and src/features/publisher.py may require updates if the site structure changes.
  • Error Handling: The project includes basic error handling. Enhancements with more specific exception management and retry mechanisms are potential areas for improvement.
  • Extensibility: To add new features:
    1. Define necessary data structures in src/data_models.py.
    2. Create new feature modules within the src/features/ directory.
    3. Integrate the new module into the TwitterOrchestrator in src/main.py.

Contributing

Contributions are welcome! Please read our CONTRIBUTING.md for guidelines on how to contribute, report bugs, or suggest enhancements.

Code of Conduct

To ensure a welcoming and inclusive environment, this project adheres to a Code of Conduct. Please review and follow it in all your interactions with the project.

License

This project is licensed under the MIT License. See the LICENSE file for details.

TODO / Future Enhancements

  • GUI or web interface for managing accounts, settings, and monitoring.
  • Advanced error handling, including robust retry logic for network issues or UI changes.
  • Integration with proxy services for enhanced multi-account management and anonymity.
  • More detailed per-account activity logging and analytics.
  • Improved AI-driven content analysis and decision-making.

For Tasks:

Click tags to check more tools for each tasks
manage multiple accounts scrape tweet content publish new tweets engage with tweets analyze competitor activity

For Jobs:

social media manager digital marketing specialist data analyst ai engineer web developer

Alternative AI tools for twitter-automation-ai

Similar Open Source Tools

twitter-automation-ai Screenshot
twitter-automation-ai

Advanced Twitter Automation AI is a modular Python-based framework for automating Twitter at scale. It supports multiple accounts, robust Selenium automation with optional undetected Chrome + stealth, per-account proxies and rotation, structured LLM generation/analysis, community posting, and per-account metrics/logs. The tool allows seamless management and automation of multiple Twitter accounts, content scraping, publishing, LLM integration for generating and analyzing tweet content, engagement automation, configurable automation, browser automation using Selenium, modular design for easy extension, comprehensive logging, community posting, stealth mode for reduced fingerprinting, per-account proxies, LLM structured prompts, and per-account JSON summaries and event logs for observability.

github
: 56
forge Screenshot
forge

Forge is a powerful open-source tool for building modern web applications. It provides a simple and intuitive interface for developers to quickly scaffold and deploy projects. With Forge, you can easily create custom components, manage dependencies, and streamline your development workflow. Whether you are a beginner or an experienced developer, Forge offers a flexible and efficient solution for your web development needs.

github
: 4.5k
backend.ai Screenshot
backend.ai

Backend.AI is a streamlined, container-based computing cluster platform that hosts popular computing/ML frameworks and diverse programming languages, with pluggable heterogeneous accelerator support including CUDA GPU, ROCm GPU, TPU, IPU and other NPUs. It allocates and isolates the underlying computing resources for multi-tenant computation sessions on-demand or in batches with customizable job schedulers with its own orchestrator. All its functions are exposed as REST/GraphQL/WebSocket APIs.

github
: 578
evolving-agents Screenshot
evolving-agents

A toolkit for agent autonomy, evolution, and governance enabling agents to learn from experience, collaborate, communicate, and build new tools within governance guardrails. It focuses on autonomous evolution, agent self-discovery, governance firmware, self-building systems, and agent-centric architecture. The toolkit leverages existing frameworks to enable agent autonomy and self-governance, moving towards truly autonomous AI systems.

github
: 403
hound Screenshot
hound

Hound is a security audit automation pipeline for AI-assisted code review that mirrors how expert auditors think, learn, and collaborate. It features graph-driven analysis, sessionized audits, provider-agnostic models, belief system and hypotheses, precise code grounding, and adaptive planning. The system employs a senior/junior auditor pattern where the Scout actively navigates the codebase and annotates knowledge graphs while the Strategist handles high-level planning and vulnerability analysis. Hound is optimized for small-to-medium sized projects like smart contract applications and is language-agnostic.

github
: 268
openai-chat-api-workflow Screenshot
openai-chat-api-workflow

**OpenAI Chat API Workflow for Alfred** An Alfred 5 Workflow for using OpenAI Chat API to interact with GPT-3.5/GPT-4 🤖💬 It also allows image generation 🖼️, image understanding 👀, speech-to-text conversion 🎤, and text-to-speech synthesis 🔈 **Features:** * Execute all features using Alfred UI, selected text, or a dedicated web UI * Web UI is constructed by the workflow and runs locally on your Mac 💻 * API call is made directly between the workflow and OpenAI, ensuring your chat messages are not shared online with anyone other than OpenAI 🔒 * OpenAI does not use the data from the API Platform for training 🚫 * Export chat data to a simple JSON format external file 📄 * Continue the chat by importing the exported data later 🔄

github
: 308
well-architected-iac-analyzer Screenshot
well-architected-iac-analyzer

Well-Architected Infrastructure as Code (IaC) Analyzer is a project demonstrating how generative AI can evaluate infrastructure code for alignment with best practices. It features a modern web application allowing users to upload IaC documents, complete IaC projects, or architecture diagrams for assessment. The tool provides insights into infrastructure code alignment with AWS best practices, offers suggestions for improving cloud architecture designs, and can generate IaC templates from architecture diagrams. Users can analyze CloudFormation, Terraform, or AWS CDK templates, architecture diagrams in PNG or JPEG format, and complete IaC projects with supporting documents. Real-time analysis against Well-Architected best practices, integration with AWS Well-Architected Tool, and export of analysis results and recommendations are included.

github
: 196
dbt-llm-agent Screenshot
dbt-llm-agent

dbt-llm-agent is an LLM-powered agent designed for interacting with dbt projects. It offers features such as question answering, documentation generation, agentic model interpretation, Postgres integration with pgvector, dbt model selection, question tracking, and upcoming Slack integration. The agent utilizes dbt project parsing, PostgreSQL with pgvector, model selection syntax, large language models like GPT-4, and question tracking to provide its functionalities. Users can set up the agent by checking Python version, cloning the repository, installing dependencies, setting up PostgreSQL with pgvector, configuring environment variables, and initializing the database schema. The agent can be initialized in Cloud Mode, Local Mode, or Source Code Mode to load project metadata. Once set up, users can work with model documentation, ask questions, provide feedback, list models, get detailed model information, and contribute to the project.

github
: 76
nano-graphrag Screenshot
nano-graphrag

nano-GraphRAG is a simple, easy-to-hack implementation of GraphRAG that provides a smaller, faster, and cleaner version of the official implementation. It is about 800 lines of code, small yet scalable, asynchronous, and fully typed. The tool supports incremental insert, async methods, and various parameters for customization. Users can replace storage components and LLM functions as needed. It also allows for embedding function replacement and comes with pre-defined prompts for entity extraction and community reports. However, some features like covariates and global search implementation differ from the original GraphRAG. Future versions aim to address issues related to data source ID, community description truncation, and add new components.

github
: 2.6k
airbadge Screenshot
airbadge

Airbadge is a Stripe addon for Auth.js that simplifies the process of creating a SaaS site by integrating payment, authentication, gating, self-service account management, webhook handling, trials & free plans, session data, and more. It allows users to launch a SaaS app without writing any authentication or payment code. The project is open source and free to use with optional paid features under the BSL License.

github
: 110
orbit Screenshot
orbit

ORBIT (Open Retrieval-Based Inference Toolkit) is a middleware platform that provides a unified API for AI inference. It acts as a central gateway, allowing you to connect various local and remote AI models with your private data sources like SQL databases, vector stores, and local files. ORBIT uses a flexible adapter architecture to connect your data to AI models, creating specialized 'agents' for specific tasks. It supports scenarios like Knowledge Base Q&A and Chat with Your SQL Database, enabling users to interact with AI models seamlessly. The tool offers a RESTful API for programmatic access and includes features like authentication, API key management, system prompts, health monitoring, and file management. ORBIT is designed to streamline AI inference tasks and facilitate interactions between users and AI models.

github
: 133
llm-functions Screenshot
llm-functions

LLM Functions is a project that enables the enhancement of large language models (LLMs) with custom tools and agents developed in bash, javascript, and python. Users can create tools for their LLM to execute system commands, access web APIs, or perform other complex tasks triggered by natural language prompts. The project provides a framework for building tools and agents, with tools being functions written in the user's preferred language and automatically generating JSON declarations based on comments. Agents combine prompts, function callings, and knowledge (RAG) to create conversational AI agents. The project is designed to be user-friendly and allows users to easily extend the capabilities of their language models.

github
: 263
pentagi Screenshot
pentagi

PentAGI is an innovative tool for automated security testing that leverages cutting-edge artificial intelligence technologies. It is designed for information security professionals, researchers, and enthusiasts who need a powerful and flexible solution for conducting penetration tests. The tool provides secure and isolated operations in a sandboxed Docker environment, fully autonomous AI-powered agent for penetration testing steps, a suite of 20+ professional security tools, smart memory system for storing research results, web intelligence for gathering information, integration with external search systems, team delegation system, comprehensive monitoring and reporting, modern interface, API integration, persistent storage, scalable architecture, self-hosted solution, flexible authentication, and quick deployment through Docker Compose.

github
: 170
DeepPavlov Screenshot
DeepPavlov

DeepPavlov is an open-source conversational AI library built on PyTorch. It is designed for the development of production-ready chatbots and complex conversational systems, as well as for research in the area of NLP and dialog systems. The library offers a wide range of models for tasks such as Named Entity Recognition, Intent/Sentence Classification, Question Answering, Sentence Similarity/Ranking, Syntactic Parsing, and more. DeepPavlov also provides embeddings like BERT, ELMo, and FastText for various languages, along with AutoML capabilities and integrations with REST API, Socket API, and Amazon AWS.

github
: 6.6k
gcop Screenshot
gcop

GCOP (Git Copilot) is an AI-powered Git assistant that automates commit message generation, enhances Git workflow, and offers 20+ smart commands. It provides intelligent commit crafting, customizable commit templates, smart learning capabilities, and a seamless developer experience. Users can generate AI commit messages, add all changes with AI-generated messages, undo commits while keeping changes staged, and push changes to the current branch. GCOP offers configuration options for AI models and provides detailed documentation, contribution guidelines, and a changelog. The tool is designed to make version control easier and more efficient for developers.

github
: 164
k8sgpt Screenshot
k8sgpt

K8sGPT is a tool for scanning your Kubernetes clusters, diagnosing, and triaging issues in simple English. It has SRE experience codified into its analyzers and helps to pull out the most relevant information to enrich it with AI.

github
: 6.4k

For similar tasks

twitter-automation-ai Screenshot
twitter-automation-ai

Advanced Twitter Automation AI is a modular Python-based framework for automating Twitter at scale. It supports multiple accounts, robust Selenium automation with optional undetected Chrome + stealth, per-account proxies and rotation, structured LLM generation/analysis, community posting, and per-account metrics/logs. The tool allows seamless management and automation of multiple Twitter accounts, content scraping, publishing, LLM integration for generating and analyzing tweet content, engagement automation, configurable automation, browser automation using Selenium, modular design for easy extension, comprehensive logging, community posting, stealth mode for reduced fingerprinting, per-account proxies, LLM structured prompts, and per-account JSON summaries and event logs for observability.

github
: 56
THE-SANDBOX-AutoClicker Screenshot
THE-SANDBOX-AutoClicker

The Sandbox AutoClicker is a bot designed for the crypto game The Sandbox, allowing users to automate various processes within the game. The tool offers features such as auto tuning, multi-account auto clicker, multi-threading, a convenient menu, and free proxies. It provides full optimization through a simple menu and is guaranteed to be safe for Windows systems, supporting versions 7/8/8.1/10/11 (x32/64).

github
: 93
kirara-ai Screenshot
kirara-ai

Kirara AI is a chatbot that supports mainstream large language models and chat platforms. It provides features such as image sending, keyword-triggered replies, multi-account support, personality settings, and support for various chat platforms like QQ, Telegram, Discord, and WeChat. The tool also supports HTTP server for Web API, popular large models like OpenAI and DeepSeek, plugin mechanism, conditional triggers, admin commands, drawing models, voice replies, multi-turn conversations, cross-platform message sending, custom workflows, web management interface, and built-in Frpc intranet penetration.

github
: 14.9k
oba-live-tool Screenshot
oba-live-tool

The oba live tool is a small tool for Douyin small shops and Kuaishou Baiying live broadcasts. It features multiple account management, intelligent message assistant, automatic product explanation, AI automatic reply, and AI intelligent assistant. The tool requires Windows 10 or above, Chrome or Edge browser, and a valid account for Douyin small shops or Kuaishou Baiying. Users can download the tool from the Releases page, connect to the control panel, set API keys for AI functions, and configure auto-reply prompts. The tool is licensed under the MIT license.

github
: 65
aomail-app Screenshot
aomail-app

Aomail is an intelligent, open-source email management platform with AI capabilities. It offers email provider integration, AI-powered tools for smart categorization and assistance, analytics and management features. Users can self-host for complete control. Coming soon features include AI custom rules, platform integration with Discord & Slack, and support for various AI providers. The tool is designed to revolutionize email management by providing advanced AI features and analytics.

github
: 63

For similar jobs

sweep Screenshot
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.

github
: 7.1k
teams-ai Screenshot
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.

github
: 502
ai-guide Screenshot
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.

github
: 159
classifai Screenshot
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.

github
: 620
chatbot-ui Screenshot
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.

github
: 27.7k
BricksLLM Screenshot
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

github
: 953
uAgents Screenshot
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.

github
: 1.3k
griptape Screenshot
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.

github
: 2.2k