Agents on Producthunt daily

cai

Thu, 25 Sep 2025 15:29:24 +0800

aliasrobotics/cai

Cybersecurity AI (`CAI`)

Cybersecurity AI (CAI) is a lightweight, open-source framework that empowers security professionals to build and deploy AI-powered offensive and defensive automation. CAI is the de facto framework for AI Security, already used by thousands of individual users and hundreds of organizations. Whether you’re a security researcher, ethical hacker, IT professional, or organization looking to enhance your security posture, CAI provides the building blocks to create specialized AI agents that can assist with mitigation, vulnerability discovery, exploitation, and security assessment.

Key Features:

🤖 300+ AI Models: Support for OpenAI, Anthropic, DeepSeek, Ollama, and more
🔧 Built-in Security Tools: Ready-to-use tools for reconnaissance, exploitation, and privilege escalation
🏆 Battle-tested: Proven in HackTheBox CTFs, bug bounties, and real-world security case studies
🎯 Agent-based Architecture: Modular framework design to build specialized agents for different security tasks
🛡️ Guardrails Protection: Built-in defenses against prompt injection and dangerous command execution
📚 Research-oriented: Research foundation to democratize cybersecurity AI for the community

[!NOTE] Read the technical report: CAI: An Open, Bug Bounty-Ready Cybersecurity AI

For further readings, refer to our impact and CAI citation sections.

`OT` - CAI and alias0 on: Ecoforest Heat Pumps	`Robotics` - CAI and alias0 on: Mobile Industrial Robots (MiR)
CAI discovers critical vulnerability in Ecoforest heat pumps allowing unauthorized remote access and potential catastrophic failures. AI-powered security testing reveals exposed credentials and DES encryption weaknesses affecting all of their deployed units across Europe.	CAI-powered security testing of MiR (Mobile Industrial Robot) platform through automated ROS message injection attacks. This study demonstrates how AI-driven vulnerability discovery can expose unauthorized access to robot control systems and alarm triggers.

`IT` (Web) - CAI and alias0 on: Mercado Libre’s e-commerce	`OT` - CAI and alias0 on: MQTT broker
CAI-powered API vulnerability discovery at Mercado Libre through automated enumeration attacks. This study demonstrates how AI-driven security testing can expose user data exposure risks in e-commerce platforms at scale.	CAI-powered testing exposed critical flaws in an MQTT broker within a Dockerized OT network. Without authentication, CAI subscribed to temperature and humidity topics and injected false values, corrupting data shown in Grafana dashboards.

[!WARNING] :warning: CAI is in active development, so don’t expect it to work flawlessly. Instead, contribute by raising an issue or sending a PR.

Access to this library and the use of information, materials (or portions thereof), is not intended, and is prohibited, where such access or use violates applicable laws or regulations. By no means the authors encourage or promote the unauthorized tampering with running systems. This can cause serious human harm and material damages.

By no means the authors of CAI encourage or promote the unauthorized tampering with compute systems. Please don’t use the source code in here for cybercrime. Pentest for good instead. By downloading, using, or modifying this source code, you agree to the terms of the LICENSE and the limitations outlined in the DISCLAIMER file.

:bookmark: Table of Contents

Cybersecurity AI (CAI)

🎯 Impact

🏆 Competitions and challenges

📊 Research Impact

Pioneered LLM-powered AI Security with PentestGPT, establishing the foundation for the Cybersecurity AI research domain
Established the Cybersecurity AI research line with 6 papers and technical reports, with active research collaborations
Demonstrated 3,600× performance improvement over human penetration testers in standardized CTF benchmark evaluations
Identified CVSS 4.3-7.5 severity vulnerabilities in production systems through automated security assessment
Democratization of AI-empowered vulnerability research: CAI enables both non-security domain experts and experienced researchers to conduct more efficient vulnerability discovery, expanding the security research community while empowering small and medium enterprises to conduct autonomous security assessments
Systematic evaluation of large language models across both proprietary and open-weight architectures, revealing substantial gaps between vendor-reported capabilities and empirical cybersecurity performance metrics
Established the autonomy levels in cybersecurity and argued about autonomy vs automation in the field
Collaborative research initiatives with international academic institutions focused on developing cybersecurity education curricula and training methodologies
Contributed a comprehensive defense framework against prompt injection in AI security agents: developed and empirically validated a multi-layered defense system that addresses the identified prompt injection issues
Explord the Cybersecurity of Humanoid Robots with CAI and identified new attack vectors showing how it (a) operates simultaneously as a covert surveillance node and (b) can be purposed as an active cyber operations platform

📚 Research products: `Cybersecurity AI`

CAI, An Open, Bug Bounty-Ready Cybersecurity AI	The Dangerous Gap Between Automation and Autonomy	CAI Fluency, A Framework for Cybersecurity AI Fluency

Hacking the AI Hackers via Prompt Injection	Humanoid Robots as Attack Vectors	The Cybersecurity of a Humanoid Robot

PoCs

CAI with `alias0` on ROS message injection attacks in MiR-100 robot	CAI with `alias0` on API vulnerability discovery at Mercado Libre

CAI on JWT@PortSwigger CTF — Cybersecurity AI	CAI on HackableII Boot2Root CTF — Cybersecurity AI

More case studies and PoCs are available at https://aliasrobotics.com/case-studies-robot-cybersecurity.php.

Motivation

:bust_in_silhouette: Why CAI?

The cybersecurity landscape is undergoing a dramatic transformation as AI becomes increasingly integrated into security operations. We predict that by 2028, AI-powered security testing tools will outnumber human pentesters. This shift represents a fundamental change in how we approach cybersecurity challenges. AI is not just another tool - it’s becoming essential for addressing complex security vulnerabilities and staying ahead of sophisticated threats. As organizations face more advanced cyber attacks, AI-enhanced security testing will be crucial for maintaining robust defenses.

This work builds upon prior efforts¹ and similarly, we believe that democratizing access to advanced cybersecurity AI tools is vital for the entire security community. That’s why we’re releasing Cybersecurity AI (CAI) as an open source framework. Our goal is to empower security researchers, ethical hackers, and organizations to build and deploy powerful AI-driven security tools. By making these capabilities openly available, we aim to level the playing field and ensure that cutting-edge security AI technology isn’t limited to well-funded private companies or state actors.

Bug Bounty programs have become a cornerstone of modern cybersecurity, providing a crucial mechanism for organizations to identify and fix vulnerabilities in their systems before they can be exploited. These programs have proven highly effective at securing both public and private infrastructure, with researchers discovering critical vulnerabilities that might have otherwise gone unnoticed. CAI is specifically designed to enhance these efforts by providing a lightweight, ergonomic framework for building specialized AI agents that can assist in various aspects of Bug Bounty hunting - from initial reconnaissance to vulnerability validation and reporting. Our framework aims to augment human expertise with AI capabilities, helping researchers work more efficiently and thoroughly in their quest to make digital systems more secure.

Ethical principles behind CAI

You might be wondering if releasing CAI in-the-wild given its capabilities and security implications is ethical. Our decision to open-source this framework is guided by two core ethical principles:

Democratizing Cybersecurity AI: We believe that advanced cybersecurity AI tools should be accessible to the entire security community, not just well-funded private companies or state actors. By releasing CAI as an open source framework, we aim to empower security researchers, ethical hackers, and organizations to build and deploy powerful AI-driven security tools, leveling the playing field in cybersecurity.
Transparency in AI Security Capabilities: Based on our research results, understanding of the technology, and dissection of top technical reports, we argue that current LLM vendors are undermining their cybersecurity capabilities. This is extremely dangerous and misleading. By developing CAI openly, we provide a transparent benchmark of what AI systems can actually do in cybersecurity contexts, enabling more informed decisions about security postures.

CAI is built on the following core principles:

Cybersecurity oriented AI framework: CAI is specifically designed for cybersecurity use cases, aiming at semi- and fully-automating offensive and defensive security tasks.
Open source, free for research: CAI is open source and free for research purposes. We aim at democratizing access to AI and Cybersecurity. For professional or commercial use, including on-premise deployments, dedicated technical support and custom extensions reach out to obtain a license.
Lightweight: CAI is designed to be fast, and easy to use.
Modular and agent-centric design: CAI operates on the basis of agents and agentic patterns, which allows flexibility and scalability. You can easily add the most suitable agents and pattern for your cybersecuritytarget case.
Tool-integration: CAI integrates already built-in tools, and allows the user to integrate their own tools with their own logic easily.
Logging and tracing integrated: using phoenix, the open source tracing and logging tool for LLMs. This provides the user with a detailed traceability of the agents and their execution.
Multi-Model Support: more than 300 supported and empowered by LiteLLM. The most popular providers:
- Anthropic: Claude 3.7, Claude 3.5, Claude 3, Claude 3 Opus
- OpenAI: O1, O1 Mini, O3 Mini, GPT-4o, GPT-4.5 Preview
- DeepSeek: DeepSeek V3, DeepSeek R1
- Ollama: Qwen2.5 72B, Qwen2.5 14B, etc

Closed-source alternatives

Cybersecurity AI is a critical field, yet many groups are misguidedly pursuing it through closed-source methods for pure economic return, leveraging similar techniques and building upon existing closed-source (often third-party owned) models. This approach not only squanders valuable engineering resources but also represents an economic waste and results in redundant efforts, as they often end up reinventing the wheel. Here are some of the closed-source initiatives we keep track of and attempting to leverage genAI and agentic frameworks in cybersecurity AI:

Learn - `CAI` Fluency

[!NOTE]

CAI Fluency technical report (arXiv:2508.13588) establishes formal educational frameworks for cybersecurity AI literacy.

	Description	English	Spanish
Episode 0: What is CAI?	Cybersecurity AI (`CAI`) explained
Episode 1: The `CAI` Framework	Vision & Ethics - Explore the core motivation behind CAI and delve into the crucial ethical principles guiding its development. Understand the motivation behind CAI and how you can actively contribute to the future of cybersecurity and the CAI framework.
Episode 2: From Zero to Cyber Hero	Breaking into Cybersecurity with AI - A comprehensive guide for complete beginners to become cybersecurity practitioners using CAI and AI tools. Learn how to leverage artificial intelligence to accelerate your cybersecurity learning journey, from understanding basic security concepts to performing real-world security assessments, all without requiring prior cybersecurity experience.
Episode 3: Vibe-Hacking Tutorial	“My first Hack” - A Vibe-Hacking guide for newbies. We demonstrate a simple web security hack using a default agent and show how to leverage tools and interpret CIA output with the help of the CAI Python API. You’ll also learn to compare different LLM models to find the best fit for your hacking endeavors.
Episode 4: Intro ReAct	The Evolution of LLMs - Learn how LLMs evolved from basic language models to advanced multiagency AI systems. From basic LLMs to Chain-of-Thought and Reasoning LLMs towards ReAct and Multi-Agent Architectures. Get to know the basic terms
Episode 5: CAI on CTF challenges	Dive into Capture The Flag (CTF) competitions using CAI. Learn how to leverage AI agents to solve various cybersecurity challenges including web exploitation, cryptography, reverse engineering, and forensics. Discover how to configure CAI for competitive hacking scenarios and maximize your CTF performance with intelligent automation.

Annex 1: `CAI` 0.5.x release	Introduce version 0.5 of `CAI` including new multi-agent functionality, new commands such as `/history`, `/compact`, `/graph` or `/memory` and a case study showing how `CAI` found a critical security flaw in OT heap pumps spread around the world.
Annex 2: `CAI` 0.4.x release and `alias0`	Introducing version 0.4 of `CAI` with streaming and improved MCP support. We also introduce `alias0`, the Privacy-First Cybersecurity AI, a Model-of-Models Intelligence that implements a Privacy-by-Design architecture and obtains state-of-the-art results in cybersecurity benchmarks.
Annex 3: Cybersecurity AI Community Meeting #1	First Cybersecurity AI (`CAI`) community meeting, over 40 participants from academia, industry, and defense gathered to discuss the open-source scaffolding behind CAI — a project designed to build agentic AI systems for cybersecurity that are open, modular, and Bug Bounty-ready.

:nut_and_bolt: Install

`1`	`pip install cai-framework`

Always create a new virtual environment to ensure proper dependency installation when updating CAI.

The following subsections provide a more detailed walkthrough on selected popular Operating Systems. Refer to the Development section for developer-related install instructions.

OS X

brew update && \
    brew install git python@3.12

# Create virtual environment
python3.12 -m venv cai_env

# Install the package from the local directory
source cai_env/bin/activate && pip install cai-framework

# Generate a .env file and set up with defaults
echo -e 'OPENAI_API_KEY="sk-1234"\nANTHROPIC_API_KEY=""\nOLLAMA=""\nPROMPT_TOOLKIT_NO_CPR=1\nCAI_STREAM=false' > .env

# Launch CAI
cai  # first launch it can take up to 30 seconds

Ubuntu 24.04

sudo apt-get update && \
    sudo apt-get install -y git python3-pip python3.12-venv

# Create the virtual environment
python3.12 -m venv cai_env

# Install the package from the local directory
source cai_env/bin/activate && pip install cai-framework

# Generate a .env file and set up with defaults
echo -e 'OPENAI_API_KEY="sk-1234"\nANTHROPIC_API_KEY=""\nOLLAMA=""\nPROMPT_TOOLKIT_NO_CPR=1\nCAI_STREAM=false' > .env

# Launch CAI
cai  # first launch it can take up to 30 seconds

Ubuntu 20.04

sudo apt-get update && \
    sudo apt-get install -y software-properties-common

# Fetch Python 3.12
sudo add-apt-repository ppa:deadsnakes/ppa && sudo apt update
sudo apt install python3.12 python3.12-venv python3.12-dev -y

# Create the virtual environment
python3.12 -m venv cai_env

# Install the package from the local directory
source cai_env/bin/activate && pip install cai-framework

# Generate a .env file and set up with defaults
echo -e 'OPENAI_API_KEY="sk-1234"\nANTHROPIC_API_KEY=""\nOLLAMA=""\nPROMPT_TOOLKIT_NO_CPR=1\nCAI_STREAM=false' > .env

# Launch CAI
cai  # first launch it can take up to 30 seconds

Windows WSL

Go to the Microsoft page: https://learn.microsoft.com/en-us/windows/wsl/install. Here you will find all the instructions to install WSL

From Powershell write: wsl –install


sudo apt-get update && \
    sudo apt-get install -y git python3-pip python3-venv

# Create the virtual environment
python3 -m venv cai_env

# Install the package from the local directory
source cai_env/bin/activate && pip install cai-framework

# Generate a .env file and set up with defaults
echo -e 'OPENAI_API_KEY="sk-1234"\nANTHROPIC_API_KEY=""\nOLLAMA=""\nPROMPT_TOOLKIT_NO_CPR=1\nCAI_STREAM=false' > .env

# Launch CAI
cai  # first launch it can take up to 30 seconds

Android

We recommend having at least 8 GB of RAM:

First of all, install userland https://play.google.com/store/apps/details?id=tech.ula&hl=es
Install Kali minimal in basic options (for free). [Or any other kali option if preferred]
Update apt keys like in this example: https://superuser.com/questions/1644520/apt-get-update-issue-in-kali, inside UserLand’s Kali terminal execute

# Get new apt keys
wget http://http.kali.org/kali/pool/main/k/kali-archive-keyring/kali-archive-keyring_2024.1_all.deb

# Install new apt keys
sudo dpkg -i kali-archive-keyring_2024.1_all.deb && rm kali-archive-keyring_2024.1_all.deb

# Update APT repository
sudo apt-get update

# CAI requieres python 3.12, lets install it (CAI for kali in Android)
sudo apt-get update && sudo apt-get install -y git python3-pip build-essential zlib1g-dev libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libreadline-dev libffi-dev libsqlite3-dev wget libbz2-dev pkg-config
wget https://www.python.org/ftp/python/3.12.4/Python-3.12.4.tar.xz
tar xf Python-3.12.4.tar.xz
cd ./configure --enable-optimizations
sudo make altinstall # This command takes long to execute

# Clone CAI's source code
git clone https://github.com/aliasrobotics/cai && cd cai

# Create virtual environment
python3.12 -m venv cai_env

# Install the package from the local directory
source cai_env/bin/activate && pip3 install -e .

# Generate a .env file and set up
cp .env.example .env  # edit here your keys/models

# Launch CAI
cai

:nut_and_bolt: Setup `.env` file

CAI leverages the .env file to load configuration at launch. To facilitate the setup, the repo provides an exemplary .env.example file provides a template for configuring CAI’s setup and your LLM API keys to work with desired LLM models.

:warning: Important:

CAI does NOT provide API keys for any model by default. Don’t ask us to provide keys, use your own or host your own models.

:warning: Note:

The OPENAI_API_KEY must not be left blank. It should contain either “sk-123” (as a placeholder) or your actual API key. See https://github.com/aliasrobotics/cai/issues/27.

:warning: Note:

If you are using alias0 model, make sure that CAI is >0.4.0 version and here you have an .env example to be able to use it.

OPENAI_API_KEY="sk-1234"
OLLAMA=""
ALIAS_API_KEY="<sk-your-key>"  # note, add yours
CAI_STEAM=False

🔹 Custom OpenAI Base URL Support

CAI supports configuring a custom OpenAI API base URL via the OPENAI_BASE_URL environment variable. This allows users to redirect API calls to a custom endpoint, such as a proxy or self-hosted OpenAI-compatible service.

Example .env entry configuration:

`1`	`OLLAMA_API_BASE="https://custom-openai-proxy.com/v1"`

Or directly from the command line:

`1`	`OLLAMA_API_BASE="https://custom-openai-proxy.com/v1" cai`

:triangular_ruler: Architecture:

CAI focuses on making cybersecurity agent coordination and execution lightweight, highly controllable, and useful for humans. To do so it builds upon 8 pillars: Agents, Tools, Handoffs, Patterns, Turns, Tracing, Guardrails and HITL.

                  ┌───────────────┐           ┌───────────┐
                  │      HITL     │◀─────────▶│   Turns   │
                  └───────┬───────┘           └───────────┘
                          │
                          ▼
┌───────────┐       ┌───────────┐       ┌───────────┐      ┌───────────┐
│  Patterns │◀─────▶│  Handoffs │◀────▶ │   Agents  │◀────▶│    LLMs   │
└───────────┘       └─────┬─────┘       └─────┬─────┘      └───────────┘
                          │                   │
                          │                   ▼
┌────────────┐       ┌────┴──────┐       ┌───────────┐     ┌────────────┐
│ Extensions │◀─────▶│  Tracing  │       │   Tools   │◀───▶│ Guardrails │
└────────────┘       └───────────┘       └───────────┘     └────────────┘
                                              │
                          ┌─────────────┬─────┴────┬─────────────┐
                          ▼             ▼          ▼             ▼
                    ┌───────────┐┌───────────┐┌────────────┐┌───────────┐
                    │ LinuxCmd  ││ WebSearch ││    Code    ││ SSHTunnel │
                    └───────────┘└───────────┘└────────────┘└───────────┘

If you want to dive deeper into the code, check the following files as a start point for using CAI:

init.py
cli.py - entrypoint for command line interface
util.py - utility functions
agents - Agent implementations
internal - CAI internal functions (endpoints, metrics, logging, etc.)
prompts - Agent Prompt Database
repl - CLI aesthetics and commands
sdk - CAI command sdk
tools - agent tools

🔹 Agent

At its core, CAI abstracts its cybersecurity behavior via Agents and agentic Patterns. An Agent in an intelligent system that interacts with some environment. More technically, within CAI we embrace a robotics-centric definition wherein an agent is anything that can be viewed as a system perceiving its environment through sensors, reasoning about its goals and and acting accordingly upon that environment through actuators (adapted from Russel & Norvig, AI: A Modern Approach). In cybersecurity, an Agent interacts with systems and networks, using peripherals and network interfaces as sensors, reasons accordingly and then executes network actions as if actuators. Correspondingly, in CAI, Agents implement the ReACT (Reasoning and Action) agent model². For more information, see the example here for the full execution code, and refer to this jupyter notebook for a tutorial on how to use it.

from cai.sdk.agents import Agent, Runner, OpenAIChatCompletionsModel

import os
from openai import AsyncOpenAI
from dotenv import load_dotenv
load_dotenv()

agent = Agent(
      name="Custom Agent",
      instructions="""You are a Cybersecurity expert Leader""",
      model=OpenAIChatCompletionsModel(
          model=os.getenv('CAI_MODEL', "openai/gpt-4o"),
          openai_client=AsyncOpenAI(),
          )
      )

message = "Tell me about recursion in programming."
result = await Runner.run(agent, message)

🔹 Tools

Tools let cybersecurity agents take actions by providing interfaces to execute system commands, run security scans, analyze vulnerabilities, and interact with target systems and APIs - they are the core capabilities that enable CAI agents to perform security tasks effectively; in CAI, tools include built-in cybersecurity utilities (like LinuxCmd for command execution, WebSearch for OSINT gathering, Code for dynamic script execution, and SSHTunnel for secure remote access), function calling mechanisms that allow integration of any Python function as a security tool, and agent-as-tool functionality that enables specialized security agents (such as reconnaissance or exploit agents) to be used by other agents, creating powerful collaborative security workflows without requiring formal handoffs between agents. For more information, please refer to the example here for the complete configuration of custom functions.

from cai.sdk.agents import Agent, Runner, OpenAIChatCompletionsModel
from cai.tools.reconnaissance.exec_code import execute_code
from cai.tools.reconnaissance.generic_linux_command import generic_linux_command

import os
from openai import AsyncOpenAI
from dotenv import load_dotenv
load_dotenv()

agent = Agent(
      name="Custom Agent",
      instructions="""You are a Cybersecurity expert Leader""",
      tools= [
        generic_linux_command,
        execute_code
      ],
      model=OpenAIChatCompletionsModel(
          model=os.getenv('CAI_MODEL', "openai/gpt-4o"),
          openai_client=AsyncOpenAI(),
          )
      )

message = "Tell me about recursion in programming."
result = await Runner.run(agent, message)

You may find different tools. They are grouped in 6 major categories inspired by the security kill chain ³:

Reconnaissance and weaponization - reconnaissance (crypto, listing, etc)
Exploitation - exploitation
Privilege escalation - escalation
Lateral movement - lateral
Data exfiltration - exfiltration
Command and control - control

🔹 Handoffs

Handoffs allow an Agent to delegate tasks to another agent, which is crucial in cybersecurity operations where specialized expertise is needed for different phases of an engagement. In our framework, Handoffs are implemented as tools for the LLM, where a handoff/transfer function like transfer_to_flag_discriminator enables the ctf_agent to pass control to the flag_discriminator_agent once it believes it has found the flag. This creates a security validation chain where the first agent handles exploitation and flag discovery, while the second agent specializes in flag verification, ensuring proper segregation of duties and leveraging specialized capabilities of different models for distinct security tasks. For more information, please refer to the example here for the full execution code.

from cai.sdk.agents import function_tool
from cai.tools.common import run_command
from cai.sdk.agents import Agent, OpenAIChatCompletionsModel, HandoffInputData, Runner, function_tool, handoff, trace
from cai.sdk.agents.extensions import handoff_filters

import os
from openai import AsyncOpenAI
from dotenv import load_dotenv
load_dotenv()

@function_tool
def execute_cli_command(command: str) -> str:
    return run_command(command)

flag_discriminator = Agent(
    name="Flag discriminator",
    description="Agent focused on extracting the flag from the output",
    instructions="You are an agent tailored to extract the flag from a given output.",
    model=OpenAIChatCompletionsModel(
        model=os.getenv('CAI_MODEL', "qwen2.5:14b"),
        openai_client=AsyncOpenAI(),
    ) 
)

ctf_agent = Agent(
    name="CTF agent",
    description="Agent focused on conquering security challenges",
    instructions="You are a Cybersecurity expert Leader facing a CTF",
    tools=[
        execute_cli_command,
    ],
    model=OpenAIChatCompletionsModel(
        model= os.getenv('CAI_MODEL', "qwen2.5:14b"),
        openai_client=AsyncOpenAI(),
    ), 
    handoffs = [flag_discriminator]
)

🔹 Patterns

An agentic Pattern is a structured design paradigm in artificial intelligence systems where autonomous or semi-autonomous agents operate within a defined interaction framework (the pattern) to achieve a goal. These Patterns specify the organization, coordination, and communication methods among agents, guiding decision-making, task execution, and delegation.

An agentic pattern (AP) can be formally defined as a tuple:

\[ AP = (A, H, D, C, E) \]

wherein:

$A$ (Agents): A set of autonomous entities, $ A = \{a_1, a_2, …, a_n\} $, each with defined roles, capabilities, and internal states.
$H$ (Handoffs): A function $ H: A \times T \to A $ that governs how tasks $ T $ are transferred between agents based on predefined logic (e.g., rules, negotiation, bidding).
$D$ (Decision Mechanism): A decision function $ D: S \to A $ where $ S $ represents system states, and $ D $ determines which agent takes action at any given time.
$C$ (Communication Protocol): A messaging function $ C: A \times A \to M $, where $ M $ is a message space, defining how agents share information.
$E$ (Execution Model): A function $ E: A \times I \to O $ where $ I $ is the input space and $ O $ is the output space, defining how agents perform tasks.

When building Patterns, we generall y classify them among one of the following categories, though others exist:

Agentic `Pattern` categories	Description
`Swarm` (Decentralized)	Agents share tasks and self-assign responsibilities without a central orchestrator. Handoffs occur dynamically. An example of a peer-to-peer agentic pattern is the `CTF Agentic Pattern`, which involves a team of agents working together to solve a CTF challenge with dynamic handoffs.
`Hierarchical`	A top-level agent (e.g., “PlannerAgent”) assigns tasks via structured handoffs to specialized sub-agents. Alternatively, the structure of the agents is harcoded into the agentic pattern with pre-defined handoffs.
`Chain-of-Thought` (Sequential Workflow)	A structured pipeline where Agent A produces an output, hands it to Agent B for reuse or refinement, and so on. Handoffs follow a linear sequence. An example of a chain-of-thought agentic pattern is the `ReasonerAgent`, which involves a Reasoning-type LLM that provides context to the main agent to solve a CTF challenge with a linear sequence.⁴
`Auction-Based` (Competitive Allocation)	Agents “bid” on tasks based on priority, capability, or cost. A decision agent evaluates bids and hands off tasks to the best-fit agent.
`Recursive`	A single agent continuously refines its own output, treating itself as both executor and evaluator, with handoffs (internal or external) to itself. An example of a recursive agentic pattern is the `CodeAgent` (when used as a recursive agent), which continuously refines its own output by executing code and updating its own instructions.

For more information and examples of common agentic patterns, see the examples folder.

🔹 Turns and Interactions

During the agentic flow (conversation), we distinguish between interactions and turns.

Interactions are sequential exchanges between one or multiple agents. Each agent executing its logic corresponds with one interaction. Since an Agent in CAI generally implements the ReACT agent model², each interaction consists of 1) a reasoning step via an LLM inference and 2) act by calling zero-to-n Tools. This is defined inprocess_interaction() in core.py.
Turns: A turn represents a cycle of one ore more interactions which finishes when the Agent (or Pattern) executing returns None, judging there’re no further actions to undertake. This is defined in run(), see core.py.

[!NOTE] CAI Agents are not related to Assistants in the Assistants API. They are named similarly for convenience, but are otherwise completely unrelated. CAI is entirely powered by the Chat Completions API and is hence stateless between calls.

🔹 Tracing

CAI implements AI observability by adopting the OpenTelemetry standard and to do so, it leverages Phoenix which provides comprehensive tracing capabilities through OpenTelemetry-based instrumentation, allowing you to monitor and analyze your security operations in real-time. This integration enables detailed visibility into agent interactions, tool usage, and attack vectors throughout penetration testing workflows, making it easier to debug complex exploitation chains, track vulnerability discovery processes, and optimize agent performance for more effective security assessments.

🔹 Guardrails

Guardrails provide a critical security layer for CAI agents, protecting against prompt injection attacks and preventing execution of dangerous commands. These guardrails run in parallel to agents, validating both input and output to ensure safe operation. The framework includes:

Input Guardrails: Detect and block prompt injection attempts before they reach agents, using pattern matching, Unicode homograph detection, and AI-powered analysis
Output Guardrails: Validate agent outputs before execution, preventing dangerous commands like reverse shells, fork bombs, or data exfiltration
Multi-layered Defense: Protection at input, processing, and execution stages with tool-level validation
Base64/Base32 Aware: Automatically decodes and analyzes encoded payloads to detect hidden malicious commands
Configurable: Can be enabled/disabled via CAI_GUARDRAILS environment variable

For detailed implementation, see docs/guardrails.md and docs/cai_prompt_injection.md.

🔹 Human-In-The-Loop (HITL)

                      ┌─────────────────────────────────┐
                      │                                 │
                      │      Cybersecurity AI (CAI)     │
                      │                                 │
                      │       ┌─────────────────┐       │
                      │       │  Autonomous AI  │       │
                      │       └────────┬────────┘       │
                      │                │                │
                      │                │                │
                      │       ┌────────▼─────────┐      │
                      │       │ HITL Interaction │      │
                      │       └────────┬─────────┘      │
                      │                │                │
                      └────────────────┼────────────────┘
                                       │
                                       │ Ctrl+C (cli.py)
                                       │
                           ┌───────────▼───────────┐
                           │   Human Operator(s)   │
                           │  Expertise | Judgment │
                           │    Teleoperation      │
                           └───────────────────────┘

CAI delivers a framework for building Cybersecurity AIs with a strong emphasis on semi-autonomous operation, as the reality is that fully-autonomous cybersecurity systems remain premature and face significant challenges when tackling complex tasks. While CAI explores autonomous capabilities, we recognize that effective security operations still require human teleoperation providing expertise, judgment, and oversight in the security process.

Accordingly, the Human-In-The-Loop (HITL) module is a core design principle of CAI, acknowledging that human intervention and teleoperation are essential components of responsible security testing. Through the cli.py interface, users can seamlessly interact with agents at any point during execution by simply pressing Ctrl+C. This is implemented across core.py and also in the REPL abstractions REPL.

:rocket: Quickstart

To start CAI after installing it, just type cai in the CLI:

└─# cai

          CCCCCCCCCCCCC      ++++++++   ++++++++      IIIIIIIIII
       CCC::::::::::::C  ++++++++++       ++++++++++  I::::::::I
     CC:::::::::::::::C ++++++++++         ++++++++++ I::::::::I
    C:::::CCCCCCCC::::C +++++++++    ++     +++++++++ II::::::II
   C:::::C       CCCCCC +++++++     +++++     +++++++   I::::I
  C:::::C                +++++     +++++++     +++++    I::::I
  C:::::C                ++++                   ++++    I::::I
  C:::::C                 ++                     ++     I::::I
  C:::::C                  +   +++++++++++++++   +      I::::I
  C:::::C                    +++++++++++++++++++        I::::I
  C:::::C                     +++++++++++++++++         I::::I
   C:::::C       CCCCCC        +++++++++++++++          I::::I
    C:::::CCCCCCCC::::C         +++++++++++++         II::::::II
     CC:::::::::::::::C           +++++++++           I::::::::I
       CCC::::::::::::C             +++++             I::::::::I
          CCCCCCCCCCCCC               ++              IIIIIIIIII

                      Cybersecurity AI (CAI), vX.Y.Z
                          Bug bounty-ready AI

CAI>

That should initialize CAI and provide a prompt to execute any security task you want to perform. The navigation bar at the bottom displays important system information. This information helps you understand your environment while working with CAI.

Here’s a quick demo video to help you get started with CAI. We’ll walk through the basic steps — from launching the tool to running your first AI-powered task in the terminal. Whether you’re a beginner or just curious, this guide will show you how easy it is to begin using CAI.

From here on, type on CAI and start your security exercise. Best way to learn is by example:

Environment Variables

For using private models, you are given a .env.example file. Copy it and rename it as .env. Fill in your corresponding API keys, and you are ready to use CAI.

List of Environment Variables

Variable	Description
CTF_NAME	Name of the CTF challenge to run (e.g. “picoctf_static_flag”)
CTF_CHALLENGE	Specific challenge name within the CTF to test
CTF_SUBNET	Network subnet for the CTF container
CTF_IP	IP address for the CTF container
CTF_INSIDE	Whether to conquer the CTF from within container
CAI_MODEL	Model to use for agents
CAI_DEBUG	Set debug output level (0: Only tool outputs, 1: Verbose debug output, 2: CLI debug output)
CAI_BRIEF	Enable/disable brief output mode
CAI_MAX_TURNS	Maximum number of turns for agent interactions
CAI_TRACING	Enable/disable OpenTelemetry tracing
CAI_AGENT_TYPE	Specify the agents to use (boot2root, one_tool…)
CAI_STATE	Enable/disable stateful mode
CAI_MEMORY	Enable/disable memory mode (episodic, semantic, all)
CAI_MEMORY_ONLINE	Enable/disable online memory mode
CAI_MEMORY_OFFLINE	Enable/disable offline memory
CAI_ENV_CONTEXT	Add dirs and current env to llm context
CAI_MEMORY_ONLINE_INTERVAL	Number of turns between online memory updates
CAI_PRICE_LIMIT	Price limit for the conversation in dollars
CAI_REPORT	Enable/disable reporter mode (ctf, nis2, pentesting)
CAI_SUPPORT_MODEL	Model to use for the support agent
CAI_SUPPORT_INTERVAL	Number of turns between support agent executions
CAI_WORKSPACE	Defines the name of the workspace
CAI_WORKSPACE_DIR	Specifies the directory path where the workspace is located
CAI_GUARDRAILS	Enable/disable guardrails for prompt injection protection (default: true)

OpenRouter Integration

The Cybersecurity AI (CAI) platform offers seamless integration with OpenRouter, a unified interface for Large Language Models (LLMs). This integration is crucial for users who wish to leverage advanced AI capabilities in their cybersecurity tasks. OpenRouter acts as a bridge, allowing CAI to communicate with various LLMs, thereby enhancing the flexibility and power of the AI agents used within CAI.

To enable OpenRouter support in CAI, you need to configure your environment by adding specific entries to your .env file. This setup ensures that CAI can interact with the OpenRouter API, facilitating the use of sophisticated models like Meta-LLaMA. Here’s how you can configure it:

CAI_AGENT_TYPE=redteam_agent
CAI_MODEL=openrouter/meta-llama/llama-4-maverick
OPENROUTER_API_KEY=<sk-your-key>  # note, add yours
OPENROUTER_API_BASE=https://openrouter.ai/api/v1

Azure OpenAI

The Cybersecurity AI (CAI) platform integrates seamlessly with Azure OpenAI, enabling organizations to run CAI against enterprise-hosted models (e.g., gpt-4o). This pathway is ideal for teams that must operate within Azure governance while leveraging advanced model capabilities. To enable Azure OpenAI support in CAI, configure your environment by adding the following entries to your .env. This ensures CAI can reach your Azure deployment endpoint and authenticate correctly.

CAI_AGENT_TYPE=redteam_agent
CAI_MODEL=azure/<model-name-deployed>
# Required: keep non-empty even when using Azure
OPENAI_API_KEY=dummy
# Azure credentials and endpoint
AZURE_API_KEY=<your-azure-openai-key>
AZURE_API_BASE=https://<resource>.openai.azure.com/openai/deployments/<deployment-name>/chat/completions?api-version=2025-01-01-preview

MCP

CAI supports the Model Context Protocol (MCP) for integrating external tools and services with AI agents. MCP is supported via two transport mechanisms:

SSE (Server-Sent Events) - For web-based servers that push updates over HTTP connections:

`1`	`CAI>/mcp load http://localhost:9876/sse burp`

STDIO (Standard Input/Output) - For local inter-process communication:

`1`	`CAI>/mcp load stdio myserver python mcp_server.py`

Once connected, you can add the MCP tools to any agent:

CAI>/mcp add burp redteam_agent
Adding tools from MCP server 'burp' to agent 'Red Team Agent'...
                                 Adding tools to Red Team Agent
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Tool                              ┃ Status ┃ Details                                         ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ send_http_request                 │ Added  │ Available as: send_http_request                 │
│ create_repeater_tab               │ Added  │ Available as: create_repeater_tab               │
│ send_to_intruder                  │ Added  │ Available as: send_to_intruder                  │
│ url_encode                        │ Added  │ Available as: url_encode                        │
│ url_decode                        │ Added  │ Available as: url_decode                        │
│ base64encode                      │ Added  │ Available as: base64encode                      │
│ base64decode                      │ Added  │ Available as: base64decode                      │
│ generate_random_string            │ Added  │ Available as: generate_random_string            │
│ output_project_options            │ Added  │ Available as: output_project_options            │
│ output_user_options               │ Added  │ Available as: output_user_options               │
│ set_project_options               │ Added  │ Available as: set_project_options               │
│ set_user_options                  │ Added  │ Available as: set_user_options                  │
│ get_proxy_http_history            │ Added  │ Available as: get_proxy_http_history            │
│ get_proxy_http_history_regex      │ Added  │ Available as: get_proxy_http_history_regex      │
│ get_proxy_websocket_history       │ Added  │ Available as: get_proxy_websocket_history       │
│ get_proxy_websocket_history_regex │ Added  │ Available as: get_proxy_websocket_history_regex │
│ set_task_execution_engine_state   │ Added  │ Available as: set_task_execution_engine_state   │
│ set_proxy_intercept_state         │ Added  │ Available as: set_proxy_intercept_state         │
│ get_active_editor_contents        │ Added  │ Available as: get_active_editor_contents        │
│ set_active_editor_contents        │ Added  │ Available as: set_active_editor_contents        │
└───────────────────────────────────┴────────┴─────────────────────────────────────────────────┘
Added 20 tools from server 'burp' to agent 'Red Team Agent'.
CAI>/agent 13
CAI>Create a repeater tab

You can list all active MCP connections and their transport types:

`1`	`CAI>/mcp list`

https://github.com/user-attachments/assets/386a1fd3-3469-4f84-9396-2a5236febe1f

Development

Development is facilitated via VS Code dev. environments. To try out our development environment, clone the repository, open VS Code and enter de dev. container mode:

Contributions

If you want to contribute to this project, use Pre-commit before your MR

1
2
3

pip install pre-commit
pre-commit # files staged
pre-commit run --all-files # all files

Optional Requirements: caiextensions

Currently, the extensions are not publicly available as the engineering endeavour to maintain them is significant. Instead, we’re making selected custom caiextensions available for partner companies across collaborations.

:information_source: Usage Data Collection

CAI is provided free of charge for researchers. To improve CAI’s detection accuracy and publish open security research, instead of payment for research use cases, we ask you to contribute to the CAI community by allowing usage data collection. This data helps us identify areas for improvement, understand how the framework is being used, and prioritize new features. Legal basis of data collection is under Art. 6 (1)(f) GDPR — CAI’s legitimate interest in maintaining and improving security tooling, with Art. 89 safeguards for research. The collected data includes:

Basic system information (OS type, Python version)
Username and IP information
Tool usage patterns and performance metrics
Model interactions and token usage statistics

We take your privacy seriously and only collect what’s needed to make CAI better. For further info, reach out to research＠aliasrobotics.com. You can disable some of the data collection features via the CAI_TELEMETRY environment variable but we encourage you to keep it enabled and contribute back to research:

`1`	`CAI_TELEMETRY=False cai`

Reproduce CI-Setup locally

To simulate the CI/CD pipeline, you can run the following in the Gitlab runner machines:

docker run --rm -it \
  --privileged \
  --network=exploitflow_net \
  --add-host="host.docker.internal:host-gateway" \
  -v /cache:/cache \
  -v /var/run/docker.sock:/var/run/docker.sock:rw \
  registry.gitlab.com/aliasrobotics/alias_research/cai:latest bash

FAQ

OLLAMA is giving me 404 errors

Ollama’s API in OpenAI mode uses /v1/chat/completions whereas the openai library uses base_url + /chat/completions.

We adopt the latter for overall alignment with the gen AI community and empower the former by allowing users to add the v1 themselves via:

`1`	`OLLAMA_API_BASE=http://IP:PORT/v1`

See the following issues that treat this topic in more detail:

Where are all the caiextensions?

See all caiextensions

How do I install the report caiextension?

See here

How do I set up SSH access for Gitlab?

Generate a new SSH key

`1`	`ssh-keygen -t ed25519`

Add the key to the SSH agent

`1`	`ssh-add ~/.ssh/id_ed25519`

Add the public key to Gitlab Copy the key and add it to Gitlab under https://gitlab.com/-/user_settings/ssh_keys

`1`	`cat ~/.ssh/id_ed25519.pub`

To verify it:

1
2

ssh -T git@gitlab.com
Welcome to GitLab, @vmayoral!

How do I clear Python cache?

`1`	`find . -name "*.pyc" -delete && find . -name "__pycache__" -delete`

If host networking is not working with ollama check whether it has been disabled in Docker because you are not signed in

Docker in OS X behaves funny sometimes. Check if the following message has shown up:

Host networking has been disabled because you are not signed in. Please sign in to enable it.

Make sure this has been addressed and also that the Dev Container is not forwarding the 8000 port (click on x, if necessary in the ports section).

To verify connection, from within the VSCode devcontainer:

`1`	`curl -v http://host.docker.internal:8000/api/version`

Run CAI against any target

The starting user prompt in this case is: Target IP: 192.168.3.10, perform a full network scan.

The agent started performing a nmap scan. You could either interact with the agent and give it more instructions, or let it run to see what it explores next.

How do I interact with the agent? Type twice CTRL + C

If you want to use the HITL mode, you can do it by presssing twice Ctrl + C. This will allow you to interact (prompt) with the agent whenever you want. The agent will not lose the previous context, as it is stored in the history variable, which is passed to it and any agent that is called. This enables any agent to use the previous information and be more accurate and efficient.

Can I change the model while CAI is running? /model

Use /model to change the model.

How can I list all the agents available? /agent

Use /agent to list all the agents available.

Where can I list all the environment variables? /config

How to know more about the CLI? /help

How can I trace the whole execution?

The environment variable `CAI_TRACING` allows the user to set it to `CAI_TRACING=true` to enable tracing, or `CAI_TRACING=false` to disable it. When CAI is prompted by the first time, the user is provided with two paths, the execution log, and the tracing log.

Can I expand CAI capabilities using previous run logs?

Yes. Today CAI performs best by relying on In‑Context Learning (ICL). Rather than building long‑term stores, the recommended workflow is to load relevant prior logs directly into the current session so the model can reason with them in context.

Use the /load command to bring JSONL logs into CAI’s context (this replaces the legacy memory-loading tool):

CAI>/load logs/cai_20250408_111856.jsonl         # Load into current agent
CAI>/load <file> agent <name>                    # Load into a specific agent
CAI>/load <file> all                             # Distribute across all agents
CAI>/load <file> parallel                        # Match to configured parallel agents
# Tip: if you omit <file>, /load uses `logs/last`. Alias: /l

CAI prints the path to the current run’s JSONL log at startup (highlighted in orange), which you can pass to /load:

Legacy notes: earlier “memory extension” mechanisms (episodic/semantic stores and offline ingestion) are retained for reference only. See src/cai/agents/memory.py for background and legacy details. Our current direction prioritizes ICL over persistent memory.

Can I expand CAI capabilities using scripts or extra information?

Currently, CAI supports text based information. You can add any extra information on the target you are facing by copy-pasting it directly into the system or user prompt.

How? By adding it to the system (system_master_template.md) or the user prompt (user_master_template.md). You can always directly prompt the path to the model, and it will cat it.

How CAI licence works?

CAI’s current license does not restrict usage for research purposes. You are free to use CAI for security assessments (pentests), to develop additional features, and to integrate it into your research activities, as long as you comply with local laws.

If you or your organization start benefiting commercially from CAI (e.g., offering pentesting services powered by CAI), then a commercial license will be required to help sustain the project.

CAI itself is not a profit-seeking initiative. Our goal is to build a sustainable open-source project. We simply ask that those who profit from CAI contribute back and support our ongoing development.

I get a `Unable to locate package python3.12-venv` when installing the prerequisites on my debian based system!

The easiest way to get around this is to simply install python3.12 from source.

Citation

If you want to cite our work, please use the following:

@misc{mayoralvilches2025caiopenbugbountyready,
      title={CAI: An Open, Bug Bounty-Ready Cybersecurity AI},
      author={Víctor Mayoral-Vilches and Luis Javier Navarrete-Lozano and María Sanz-Gómez and Lidia Salas Espejo and Martiño Crespo-Álvarez and Francisco Oca-Gonzalez and Francesco Balassone and Alfonso Glera-Picón and Unai Ayucar-Carbajo and Jon Ander Ruiz-Alcalde and Stefan Rass and Martin Pinzger and Endika Gil-Uriarte},
      year={2025},
      eprint={2504.06017},
      archivePrefix={arXiv},
      primaryClass={cs.CR},
      url={https://arxiv.org/abs/2504.06017},
}

@misc{mayoralvilches2025cybersecurityaidangerousgap,
      title={Cybersecurity AI: The Dangerous Gap Between Automation and Autonomy}, 
      author={Víctor Mayoral-Vilches},
      year={2025},
      eprint={2506.23592},
      archivePrefix={arXiv},
      primaryClass={cs.CR},
      url={https://arxiv.org/abs/2506.23592}, 
}

@misc{mayoralvilches2025caifluencyframeworkcybersecurity,
      title={CAI Fluency: A Framework for Cybersecurity AI Fluency}, 
      author={Víctor Mayoral-Vilches and Jasmin Wachter and Cristóbal R. J. Veas Chavez and Cathrin Schachner and Luis Javier Navarrete-Lozano and María Sanz-Gómez},
      year={2025},
      eprint={2508.13588},
      archivePrefix={arXiv},
      primaryClass={cs.CR},
      url={https://arxiv.org/abs/2508.13588}, 
}

@misc{mayoralvilches2025cybersecurityaihackingai,
      title={Cybersecurity AI: Hacking the AI Hackers via Prompt Injection}, 
      author={Víctor Mayoral-Vilches and Per Mannermaa Rynning},
      year={2025},
      eprint={2508.21669},
      archivePrefix={arXiv},
      primaryClass={cs.CR},
      url={https://arxiv.org/abs/2508.21669}, 
}

Acknowledgements

CAI was initially developed by Alias Robotics and co-funded by the European EIC accelerator project RIS (GA 101161136) - HORIZON-EIC-2023-ACCELERATOR-01 call. The original agentic principles are inspired from OpenAI’s swarm library and translated into newer prototypes. This project also makes use of other relevant open source building blocks including LiteLLM, and phoenix

Academic Collaborations

CAI benefits from ongoing research collaborations with academic institutions. Researchers interested in collaborative projects, dataset access, or academic licenses should contact research@aliasrobotics.com. We provide special support for:

PhD research projects
Academic benchmarking studies
Security education initiatives
Open-source contributions from research labs

Deng, G., Liu, Y., Mayoral-Vilches, V., Liu, P., Li, Y., Xu, Y., … & Rass, S. (2024). {PentestGPT}: Evaluating and harnessing large language models for automated penetration testing. In 33rd USENIX Security Symposium (USENIX Security 24) (pp. 847-864). ↩︎
Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., & Cao, Y. (2023, January). React: Synergizing reasoning and acting in language models. In International Conference on Learning Representations (ICLR). ↩︎ ↩︎
Kamhoua, C. A., Leslie, N. O., & Weisman, M. J. (2018). Game theoretic modeling of advanced persistent threat in internet of things. Journal of Cyber Security and Information Systems. ↩︎
Arguably, the Chain-of-Thought agentic pattern is a special case of the Hierarchical agentic pattern. ↩︎

crewAI

Fri, 05 Sep 2025 15:27:04 +0800

crewAIInc/crewAI

Homepage · Docs · Start Cloud Trial · Blog · Forum

Fast and Flexible Multi-Agent Automation Framework

CrewAI is a lean, lightning-fast Python framework built entirely from scratch—completely independent of LangChain or other agent frameworks. It empowers developers with both high-level simplicity and precise low-level control, ideal for creating autonomous AI agents tailored to any scenario.

CrewAI Crews: Optimize for autonomy and collaborative intelligence.
CrewAI Flows: Enable granular, event-driven control, single LLM calls for precise task orchestration and supports Crews natively

With over 100,000 developers certified through our community courses at learn.crewai.com, CrewAI is rapidly becoming the standard for enterprise-ready AI automation.

CrewAI Enterprise Suite

CrewAI Enterprise Suite is a comprehensive bundle tailored for organizations that require secure, scalable, and easy-to-manage agent-driven automation.

You can try one part of the suite the Crew Control Plane for free

Crew Control Plane Key Features:

Tracing & Observability: Monitor and track your AI agents and workflows in real-time, including metrics, logs, and traces.
Unified Control Plane: A centralized platform for managing, monitoring, and scaling your AI agents and workflows.
Seamless Integrations: Easily connect with existing enterprise systems, data sources, and cloud infrastructure.
Advanced Security: Built-in robust security and compliance measures ensuring safe deployment and management.
Actionable Insights: Real-time analytics and reporting to optimize performance and decision-making.
24/7 Support: Dedicated enterprise support to ensure uninterrupted operation and quick resolution of issues.
On-premise and Cloud Deployment Options: Deploy CrewAI Enterprise on-premise or in the cloud, depending on your security and compliance requirements.

CrewAI Enterprise is designed for enterprises seeking a powerful, reliable solution to transform complex business processes into efficient, intelligent automations.

Why CrewAI?

CrewAI unlocks the true potential of multi-agent automation, delivering the best-in-class combination of speed, flexibility, and control with either Crews of AI Agents or Flows of Events:

Standalone Framework: Built from scratch, independent of LangChain or any other agent framework.
High Performance: Optimized for speed and minimal resource usage, enabling faster execution.
Flexible Low Level Customization: Complete freedom to customize at both high and low levels - from overall workflows and system architecture to granular agent behaviors, internal prompts, and execution logic.
Ideal for Every Use Case: Proven effective for both simple tasks and highly complex, real-world, enterprise-grade scenarios.
Robust Community: Backed by a rapidly growing community of over 100,000 certified developers offering comprehensive support and resources.

CrewAI empowers developers and enterprises to confidently build intelligent automations, bridging the gap between simplicity, flexibility, and performance.

Getting Started

Setup and run your first CrewAI agents by following this tutorial.

Learning Resources

Learn CrewAI through our comprehensive courses:

Multi AI Agent Systems with CrewAI - Master the fundamentals of multi-agent systems
Practical Multi AI Agents and Advanced Use Cases - Deep dive into advanced implementations

Understanding Flows and Crews

CrewAI offers two powerful, complementary approaches that work seamlessly together to build sophisticated AI applications:

Crews: Teams of AI agents with true autonomy and agency, working together to accomplish complex tasks through role-based collaboration. Crews enable:
- Natural, autonomous decision-making between agents
- Dynamic task delegation and collaboration
- Specialized roles with defined goals and expertise
- Flexible problem-solving approaches
Flows: Production-ready, event-driven workflows that deliver precise control over complex automations. Flows provide:
- Fine-grained control over execution paths for real-world scenarios
- Secure, consistent state management between tasks
- Clean integration of AI agents with production Python code
- Conditional branching for complex business logic

The true power of CrewAI emerges when combining Crews and Flows. This synergy allows you to:

Build complex, production-grade applications
Balance autonomy with precise control
Handle sophisticated real-world scenarios
Maintain clean, maintainable code structure

Getting Started with Installation

To get started with CrewAI, follow these simple steps:

1. Installation

Ensure you have Python >=3.10 <3.14 installed on your system. CrewAI uses UV for dependency management and package handling, offering a seamless setup and execution experience.

First, install CrewAI:

`1`	`pip install crewai`

If you want to install the ‘crewai’ package along with its optional features that include additional tools for agents, you can do so by using the following command:

`1`	`pip install 'crewai[tools]'`

The command above installs the basic package and also adds extra components which require more dependencies to function.

Troubleshooting Dependencies

If you encounter issues during installation or usage, here are some common solutions:

Common Issues

ModuleNotFoundError: No module named ’tiktoken’
- Install tiktoken explicitly: pip install 'crewai[embeddings]'
- If using embedchain or other tools: pip install 'crewai[tools]'
Failed building wheel for tiktoken
- Ensure Rust compiler is installed (see installation steps above)
- For Windows: Verify Visual C++ Build Tools are installed
- Try upgrading pip: pip install --upgrade pip
- If issues persist, use a pre-built wheel: pip install tiktoken --prefer-binary

2. Setting Up Your Crew with the YAML Configuration

To create a new CrewAI project, run the following CLI (Command Line Interface) command:

`1`	`crewai create crew <project_name>`

This command creates a new project folder with the following structure:

my_project/
├── .gitignore
├── pyproject.toml
├── README.md
├── .env
└── src/
    └── my_project/
        ├── __init__.py
        ├── main.py
        ├── crew.py
        ├── tools/
        │   ├── custom_tool.py
        │   └── __init__.py
        └── config/
            ├── agents.yaml
            └── tasks.yaml

You can now start developing your crew by editing the files in the src/my_project folder. The main.py file is the entry point of the project, the crew.py file is where you define your crew, the agents.yaml file is where you define your agents, and the tasks.yaml file is where you define your tasks.

To customize your project, you can:

Modify src/my_project/config/agents.yaml to define your agents.
Modify src/my_project/config/tasks.yaml to define your tasks.
Modify src/my_project/crew.py to add your own logic, tools, and specific arguments.
Modify src/my_project/main.py to add custom inputs for your agents and tasks.
Add your environment variables into the .env file.

Example of a simple crew with a sequential process:

Instantiate your crew:

`1`	`crewai create crew latest-ai-development`

Modify the files as needed to fit your use case:

agents.yaml

# src/my_project/config/agents.yaml
researcher:
  role: >
    {topic} Senior Data Researcher
  goal: >
    Uncover cutting-edge developments in {topic}
  backstory: >
    You're a seasoned researcher with a knack for uncovering the latest
    developments in {topic}. Known for your ability to find the most relevant
    information and present it in a clear and concise manner.

reporting_analyst:
  role: >
    {topic} Reporting Analyst
  goal: >
    Create detailed reports based on {topic} data analysis and research findings
  backstory: >
    You're a meticulous analyst with a keen eye for detail. You're known for
    your ability to turn complex data into clear and concise reports, making
    it easy for others to understand and act on the information you provide.

tasks.yaml

# src/my_project/config/tasks.yaml
research_task:
  description: >
    Conduct a thorough research about {topic}
    Make sure you find any interesting and relevant information given
    the current year is 2025.
  expected_output: >
    A list with 10 bullet points of the most relevant information about {topic}
  agent: researcher

reporting_task:
  description: >
    Review the context you got and expand each topic into a full section for a report.
    Make sure the report is detailed and contains any and all relevant information.
  expected_output: >
    A fully fledge reports with the mains topics, each with a full section of information.
    Formatted as markdown without '```'
  agent: reporting_analyst
  output_file: report.md

crew.py

# src/my_project/crew.py
from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from crewai_tools import SerperDevTool
from crewai.agents.agent_builder.base_agent import BaseAgent
from typing import List

@CrewBase
class LatestAiDevelopmentCrew():
	"""LatestAiDevelopment crew"""
	agents: List[BaseAgent]
	tasks: List[Task]

	@agent
	def researcher(self) -> Agent:
		return Agent(
			config=self.agents_config['researcher'],
			verbose=True,
			tools=[SerperDevTool()]
		)

	@agent
	def reporting_analyst(self) -> Agent:
		return Agent(
			config=self.agents_config['reporting_analyst'],
			verbose=True
		)

	@task
	def research_task(self) -> Task:
		return Task(
			config=self.tasks_config['research_task'],
		)

	@task
	def reporting_task(self) -> Task:
		return Task(
			config=self.tasks_config['reporting_task'],
			output_file='report.md'
		)

	@crew
	def crew(self) -> Crew:
		"""Creates the LatestAiDevelopment crew"""
		return Crew(
			agents=self.agents, # Automatically created by the @agent decorator
			tasks=self.tasks, # Automatically created by the @task decorator
			process=Process.sequential,
			verbose=True,
		)

main.py

#!/usr/bin/env python
# src/my_project/main.py
import sys
from latest_ai_development.crew import LatestAiDevelopmentCrew

def run():
    """
    Run the crew.
    """
    inputs = {
        'topic': 'AI Agents'
    }
    LatestAiDevelopmentCrew().crew().kickoff(inputs=inputs)

3. Running Your Crew

Before running your crew, make sure you have the following keys set as environment variables in your .env file:

An OpenAI API key (or other LLM API key): OPENAI_API_KEY=sk-...
A Serper.dev API key: SERPER_API_KEY=YOUR_KEY_HERE

Lock the dependencies and install them by using the CLI command but first, navigate to your project directory:

1
2

cd my_project
crewai install (Optional)

To run your crew, execute the following command in the root of your project:

`1`	`crewai run`

`1`	`python src/my_project/main.py`

If an error happens due to the usage of poetry, please run the following command to update your crewai package:

`1`	`crewai update`

You should see the output in the console and the report.md file should be created in the root of your project with the full final report.

In addition to the sequential process, you can use the hierarchical process, which automatically assigns a manager to the defined crew to properly coordinate the planning and execution of tasks through delegation and validation of results. See more about the processes here.

Key Features

CrewAI stands apart as a lean, standalone, high-performance multi-AI Agent framework delivering simplicity, flexibility, and precise control—free from the complexity and limitations found in other agent frameworks.

Standalone & Lean: Completely independent from other frameworks like LangChain, offering faster execution and lighter resource demands.
Flexible & Precise: Easily orchestrate autonomous agents through intuitive Crews or precise Flows, achieving perfect balance for your needs.
Seamless Integration: Effortlessly combine Crews (autonomy) and Flows (precision) to create complex, real-world automations.
Deep Customization: Tailor every aspect—from high-level workflows down to low-level internal prompts and agent behaviors.
Reliable Performance: Consistent results across simple tasks and complex, enterprise-level automations.
Thriving Community: Backed by robust documentation and over 100,000 certified developers, providing exceptional support and guidance.

Choose CrewAI to easily build powerful, adaptable, and production-ready AI automations.

Examples

You can test different real life examples of AI crews in the CrewAI-examples repo:

Quick Tutorial

Using Crews and Flows Together

CrewAI’s power truly shines when combining Crews with Flows to create sophisticated automation pipelines. CrewAI flows support logical operators like or_ and and_ to combine multiple conditions. This can be used with @start, @listen, or @router decorators to create complex triggering conditions.

or_: Triggers when any of the specified conditions are met.
and_Triggers when all of the specified conditions are met.

Here’s how you can orchestrate multiple Crews within a Flow:

from crewai.flow.flow import Flow, listen, start, router, or_
from crewai import Crew, Agent, Task, Process
from pydantic import BaseModel

# Define structured state for precise control
class MarketState(BaseModel):
    sentiment: str = "neutral"
    confidence: float = 0.0
    recommendations: list = []

class AdvancedAnalysisFlow(Flow[MarketState]):
    @start()
    def fetch_market_data(self):
        # Demonstrate low-level control with structured state
        self.state.sentiment = "analyzing"
        return {"sector": "tech", "timeframe": "1W"}  # These parameters match the task description template

    @listen(fetch_market_data)
    def analyze_with_crew(self, market_data):
        # Show crew agency through specialized roles
        analyst = Agent(
            role="Senior Market Analyst",
            goal="Conduct deep market analysis with expert insight",
            backstory="You're a veteran analyst known for identifying subtle market patterns"
        )
        researcher = Agent(
            role="Data Researcher",
            goal="Gather and validate supporting market data",
            backstory="You excel at finding and correlating multiple data sources"
        )

        analysis_task = Task(
            description="Analyze {sector} sector data for the past {timeframe}",
            expected_output="Detailed market analysis with confidence score",
            agent=analyst
        )
        research_task = Task(
            description="Find supporting data to validate the analysis",
            expected_output="Corroborating evidence and potential contradictions",
            agent=researcher
        )

        # Demonstrate crew autonomy
        analysis_crew = Crew(
            agents=[analyst, researcher],
            tasks=[analysis_task, research_task],
            process=Process.sequential,
            verbose=True
        )
        return analysis_crew.kickoff(inputs=market_data)  # Pass market_data as named inputs

    @router(analyze_with_crew)
    def determine_next_steps(self):
        # Show flow control with conditional routing
        if self.state.confidence > 0.8:
            return "high_confidence"
        elif self.state.confidence > 0.5:
            return "medium_confidence"
        return "low_confidence"

    @listen("high_confidence")
    def execute_strategy(self):
        # Demonstrate complex decision making
        strategy_crew = Crew(
            agents=[
                Agent(role="Strategy Expert",
                      goal="Develop optimal market strategy")
            ],
            tasks=[
                Task(description="Create detailed strategy based on analysis",
                     expected_output="Step-by-step action plan")
            ]
        )
        return strategy_crew.kickoff()

    @listen(or_("medium_confidence", "low_confidence"))
    def request_additional_analysis(self):
        self.state.recommendations.append("Gather more data")
        return "Additional analysis required"

This example demonstrates how to:

Use Python code for basic data operations
Create and execute Crews as steps in your workflow
Use Flow decorators to manage the sequence of operations
Implement conditional branching based on Crew results

Connecting Your Crew to a Model

CrewAI supports using various LLMs through a variety of connection options. By default your agents will use the OpenAI API when querying the model. However, there are several other ways to allow your agents to connect to models. For example, you can configure your agents to use a local model via the Ollama tool.

Please refer to the Connect CrewAI to LLMs page for details on configuring your agents’ connections to models.

How CrewAI Compares

CrewAI’s Advantage: CrewAI combines autonomous agent intelligence with precise workflow control through its unique Crews and Flows architecture. The framework excels at both high-level orchestration and low-level customization, enabling complex, production-grade systems with granular control.

LangGraph: While LangGraph provides a foundation for building agent workflows, its approach requires significant boilerplate code and complex state management patterns. The framework’s tight coupling with LangChain can limit flexibility when implementing custom agent behaviors or integrating with external systems.

P.S. CrewAI demonstrates significant performance advantages over LangGraph, executing 5.76x faster in certain cases like this QA task example (see comparison) while achieving higher evaluation scores with faster completion times in certain coding tasks, like in this example (detailed analysis).

Autogen: While Autogen excels at creating conversational agents capable of working together, it lacks an inherent concept of process. In Autogen, orchestrating agents’ interactions requires additional programming, which can become complex and cumbersome as the scale of tasks grows.
ChatDev: ChatDev introduced the idea of processes into the realm of AI agents, but its implementation is quite rigid. Customizations in ChatDev are limited and not geared towards production environments, which can hinder scalability and flexibility in real-world applications.

Contribution

CrewAI is open-source and we welcome contributions. If you’re looking to contribute, please:

Fork the repository.
Create a new branch for your feature.
Add your feature or improvement.
Send a pull request.
We appreciate your input!

Installing Dependencies

1
2

uv lock
uv sync

Virtual Env

uv venv

Pre-commit hooks

`1`	`pre-commit install`

Running Tests

`1`	`uv run pytest .`

Running static type checks

`1`	`uvx mypy src`

Packaging

`1`	`uv build`

Installing Locally

`1`	`pip install dist/*.tar.gz`

Telemetry

CrewAI uses anonymous telemetry to collect usage data with the main purpose of helping us improve the library by focusing our efforts on the most used features, integrations and tools.

It’s pivotal to understand that NO data is collected concerning prompts, task descriptions, agents’ backstories or goals, usage of tools, API calls, responses, any data processed by the agents, or secrets and environment variables, with the exception of the conditions mentioned. When the share_crew feature is enabled, detailed data including task descriptions, agents’ backstories or goals, and other specific attributes are collected to provide deeper insights while respecting user privacy. Users can disable telemetry by setting the environment variable OTEL_SDK_DISABLED to true.

Data collected includes:

Version of CrewAI
- So we can understand how many users are using the latest version
Version of Python
- So we can decide on what versions to better support
General OS (e.g. number of CPUs, macOS/Windows/Linux)
- So we know what OS we should focus on and if we could build specific OS related features
Number of agents and tasks in a crew
- So we make sure we are testing internally with similar use cases and educate people on the best practices
Crew Process being used
- Understand where we should focus our efforts
If Agents are using memory or allowing delegation
- Understand if we improved the features or maybe even drop them
If Tasks are being executed in parallel or sequentially
- Understand if we should focus more on parallel execution
Language model being used
- Improved support on most used languages
Roles of agents in a crew
- Understand high level use cases so we can build better tools, integrations and examples about it
Tools names available
- Understand out of the publicly available tools, which ones are being used the most so we can improve them

Users can opt-in to Further Telemetry, sharing the complete telemetry data by setting the share_crew attribute to True on their Crews. Enabling share_crew results in the collection of detailed crew and task execution data, including goal, backstory, context, and output of tasks. This enables a deeper insight into usage patterns while respecting the user’s choice to share.

License

CrewAI is released under the MIT License.

Frequently Asked Questions (FAQ)

General

Features and Capabilities

Resources and Community

Enterprise Features

Q: What exactly is CrewAI?

A: CrewAI is a standalone, lean, and fast Python framework built specifically for orchestrating autonomous AI agents. Unlike frameworks like LangChain, CrewAI does not rely on external dependencies, making it leaner, faster, and simpler.

Q: How do I install CrewAI?

A: Install CrewAI using pip:

`1`	`pip install crewai`

For additional tools, use:

`1`	`pip install 'crewai[tools]'`

Q: Does CrewAI depend on LangChain?

A: No. CrewAI is built entirely from the ground up, with no dependencies on LangChain or other agent frameworks. This ensures a lean, fast, and flexible experience.

Q: Can CrewAI handle complex use cases?

A: Yes. CrewAI excels at both simple and highly complex real-world scenarios, offering deep customization options at both high and low levels, from internal prompts to sophisticated workflow orchestration.

Q: Can I use CrewAI with local AI models?

A: Absolutely! CrewAI supports various language models, including local ones. Tools like Ollama and LM Studio allow seamless integration. Check the LLM Connections documentation for more details.

Q: What makes Crews different from Flows?

A: Crews provide autonomous agent collaboration, ideal for tasks requiring flexible decision-making and dynamic interaction. Flows offer precise, event-driven control, ideal for managing detailed execution paths and secure state management. You can seamlessly combine both for maximum effectiveness.

Q: How is CrewAI better than LangChain?

A: CrewAI provides simpler, more intuitive APIs, faster execution speeds, more reliable and consistent results, robust documentation, and an active community—addressing common criticisms and limitations associated with LangChain.

Q: Is CrewAI open-source?

A: Yes, CrewAI is open-source and actively encourages community contributions and collaboration.

Q: Does CrewAI collect data from users?

A: CrewAI collects anonymous telemetry data strictly for improvement purposes. Sensitive data such as prompts, tasks, or API responses are never collected unless explicitly enabled by the user.

Q: Where can I find real-world CrewAI examples?

A: Check out practical examples in the CrewAI-examples repository, covering use cases like trip planners, stock analysis, and job postings.

Q: How can I contribute to CrewAI?

A: Contributions are warmly welcomed! Fork the repository, create your branch, implement your changes, and submit a pull request. See the Contribution section of the README for detailed guidelines.

Q: What additional features does CrewAI Enterprise offer?

A: CrewAI Enterprise provides advanced features such as a unified control plane, real-time observability, secure integrations, advanced security, actionable insights, and dedicated 24/7 enterprise support.

Q: Is CrewAI Enterprise available for cloud and on-premise deployments?

A: Yes, CrewAI Enterprise supports both cloud-based and on-premise deployment options, allowing enterprises to meet their specific security and compliance requirements.

Q: Can I try CrewAI Enterprise for free?

A: Yes, you can explore part of the CrewAI Enterprise Suite by accessing the Crew Control Plane for free.

Q: Does CrewAI support fine-tuning or training custom models?

A: Yes, CrewAI can integrate with custom-trained or fine-tuned models, allowing you to enhance your agents with domain-specific knowledge and accuracy.

Q: Can CrewAI agents interact with external tools and APIs?

A: Absolutely! CrewAI agents can easily integrate with external tools, APIs, and databases, empowering them to leverage real-world data and resources.

Q: Is CrewAI suitable for production environments?

A: Yes, CrewAI is explicitly designed with production-grade standards, ensuring reliability, stability, and scalability for enterprise deployments.

Q: How scalable is CrewAI?

A: CrewAI is highly scalable, supporting simple automations and large-scale enterprise workflows involving numerous agents and complex tasks simultaneously.

Q: Does CrewAI offer debugging and monitoring tools?

A: Yes, CrewAI Enterprise includes advanced debugging, tracing, and real-time observability features, simplifying the management and troubleshooting of your automations.

Q: What programming languages does CrewAI support?

A: CrewAI is primarily Python-based but easily integrates with services and APIs written in any programming language through its flexible API integration capabilities.

Q: Does CrewAI offer educational resources for beginners?

A: Yes, CrewAI provides extensive beginner-friendly tutorials, courses, and documentation through learn.crewai.com, supporting developers at all skill levels.

Q: Can CrewAI automate human-in-the-loop workflows?

A: Yes, CrewAI fully supports human-in-the-loop workflows, allowing seamless collaboration between human experts and AI agents for enhanced decision-making.

koog

Wed, 03 Sep 2025 15:26:34 +0800

JetBrains/koog

Koog

Overview

Koog is a Kotlin-based framework designed to build and run AI agents entirely in idiomatic Kotlin. It lets you create agents that can interact with tools, handle complex workflows, and communicate with users.

Key features

Key features of Koog include:

Pure Kotlin implementation: Build AI agents entirely in natural and idiomatic Kotlin.
MCP integration: Connect to Model Context Protocol for enhanced model management.
Embedding capabilities: Use vector embeddings for semantic search and knowledge retrieval.
Custom tool creation: Extend your agents with tools that access external systems and APIs.
Ready-to-use components: Speed up development with pre-built solutions for common AI engineering challenges.
Intelligent history compression: Optimize token usage while maintaining conversation context using various pre-built strategies.
Powerful Streaming API: Process responses in real-time with streaming support and parallel tool calls.
Persistent agent memory: Enable knowledge retention across sessions and even different agents.
Comprehensive tracing: Debug and monitor agent execution with detailed and configurable tracing.
Flexible graph workflows: Design complex agent behaviors using intuitive graph-based workflows.
Modular feature system: Customize agent capabilities through a composable architecture.
Scalable architecture: Handle workloads from simple chatbots to enterprise applications.
Multiplatform: Run agents on JVM, JS, WasmJS, iOS targets with Kotlin Multiplatform.

Available LLM providers and platforms

The LLM providers and platforms whose LLMs you can use to power your agent capabilities:

Google
OpenAI
Anthropic
OpenRouter
Ollama

Quickstart example

To help you get started with AI agents, here is a quick example:

fun main() = runBlocking {
    // Before you run the example, assign a corresponding API key as an environment variable.
   val apiKey = System.getenv("OPENAI_API_KEY") // or Anthropic, Google, OpenRouter, etc.

   val agent = AIAgent(
      executor = simpleOpenAIExecutor(apiKey), // or Anthropic, Google, OpenRouter, etc.
      systemPrompt = "You are a helpful assistant. Answer user questions concisely.",
      llmModel = OpenAIModels.Chat.GPT4o
   )

   val result = agent.run("Hello! How can you help me?")
   println(result)
}

Using in your projects

Supported targets

Currently, the framework supports the JVM, JS, WasmJS and iOS targets.

On JVM, JDK 17 or higher is required to use the framework.

Please check the libs.versions.toml to know more about the Koog dependencies.

Gradle (Kotlin DSL)

Add dependencies to the build.gradle.kts file:

1
2
3

dependencies {
    implementation("ai.koog:koog-agents:0.4.1")
}

Make sure that you have mavenCentral() in the list of repositories.

Gradle (Groovy)

Add dependencies to the build.gradle file:

1
2
3

dependencies {
    implementation 'ai.koog:koog-agents:0.4.1'
}

Make sure that you have mavenCentral() in the list of repositories.

Maven

Add dependencies to the pom.xml file:

<dependency>
    <groupId>ai.koog</groupId>
    <artifactId>koog-agents-jvm</artifactId>
    <version>0.4.1</version>
</dependency>

Make sure that you have mavenCentral in the list of repositories.

Contributing

Read the Contributing Guidelines.

Code of Conduct

This project and the corresponding community are governed by the JetBrains Open Source and Community Code of Conduct. Please make sure you read it.

License

Koog is licensed under the Apache 2.0 License.

Support

Please feel free to ask any questions in our official Slack channel (link) and to use Koog official YouTrack project for filing feature requests and bug reports.

genai-toolbox

Thu, 28 Aug 2025 15:29:14 +0800

googleapis/genai-toolbox

MCP Toolbox for Databases

[!NOTE] MCP Toolbox for Databases is currently in beta, and may see breaking changes until the first stable release (v1.0).

MCP Toolbox for Databases is an open source MCP server for databases. It enables you to develop tools easier, faster, and more securely by handling the complexities such as connection pooling, authentication, and more.

This README provides a brief overview. For comprehensive details, see the full documentation.

[!NOTE] This solution was originally named “Gen AI Toolbox for Databases” as its initial development predated MCP, but was renamed to align with recently added MCP compatibility.

Why Toolbox?

Toolbox helps you build Gen AI tools that let your agents access data in your database. Toolbox provides:

Simplified development: Integrate tools to your agent in less than 10 lines of code, reuse tools between multiple agents or frameworks, and deploy new versions of tools more easily.
Better performance: Best practices such as connection pooling, authentication, and more.
Enhanced security: Integrated auth for more secure access to your data
End-to-end observability: Out of the box metrics and tracing with built-in support for OpenTelemetry.

⚡ Supercharge Your Workflow with an AI Database Assistant ⚡

Stop context-switching and let your AI assistant become a true co-developer. By connecting your IDE to your databases with MCP Toolbox, you can delegate complex and time-consuming database tasks, allowing you to build faster and focus on what matters. This isn’t just about code completion; it’s about giving your AI the context it needs to handle the entire development lifecycle.

Here’s how it will save you time:

Query in Plain English: Interact with your data using natural language right from your IDE. Ask complex questions like, “How many orders were delivered in 2024, and what items were in them?” without writing any SQL.
Automate Database Management: Simply describe your data needs, and let the AI assistant manage your database for you. It can handle generating queries, creating tables, adding indexes, and more.
Generate Context-Aware Code: Empower your AI assistant to generate application code and tests with a deep understanding of your real-time database schema. This accelerates the development cycle by ensuring the generated code is directly usable.
Slash Development Overhead: Radically reduce the time spent on manual setup and boilerplate. MCP Toolbox helps streamline lengthy database configurations, repetitive code, and error-prone schema migrations.

Learn how to connect your AI tools (IDEs) to Toolbox using MCP.

General Architecture

Toolbox sits between your application’s orchestration framework and your database, providing a control plane that is used to modify, distribute, or invoke tools. It simplifies the management of your tools by providing you with a centralized location to store and update tools, allowing you to share tools between agents and applications and update those tools without necessarily redeploying your application.

Getting Started

Installing the server

For the latest version, check the releases page and use the following instructions for your OS and CPU architecture.

Binary

To install Toolbox as a binary:

# see releases page for other versions
export VERSION=0.13.0
curl -O https://storage.googleapis.com/genai-toolbox/v$VERSION/linux/amd64/toolbox
chmod +x toolbox

Container image

You can also install Toolbox as a container:

1
2
3

# see releases page for other versions
export VERSION=0.13.0
docker pull us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:$VERSION

Homebrew

To install Toolbox using Homebrew on macOS or Linux:

`1`	`brew install mcp-toolbox`

Compile from source

To install from source, ensure you have the latest version of Go installed, and then run the following command:

`1`	`go install github.com/googleapis/genai-toolbox@v0.13.0`

Running the server

Configure a tools.yaml to define your tools, and then execute toolbox to start the server:

`1`	`./toolbox --tools-file "tools.yaml"`

[!NOTE] Toolbox enables dynamic reloading by default. To disable, use the --disable-reload flag.

Homebrew Users

If you installed Toolbox using Homebrew, the toolbox binary is available in your system path. You can start the server with the same command:

`1`	`toolbox --tools-file "tools.yaml"`

You can use toolbox help for a full list of flags! To stop the server, send a terminate signal (ctrl+c on most platforms).

For more detailed documentation on deploying to different environments, check out the resources in the How-to section

Integrating your application

Once your server is up and running, you can load the tools into your application. See below the list of Client SDKs for using various frameworks:

Python (Github)

Core

Install Toolbox Core SDK:
1

pip install toolbox-core

Load tools:

from toolbox_core import ToolboxClient

# update the url to point to your server
async with ToolboxClient("http://127.0.0.1:5000") as client:

    # these tools can be passed to your application!
    tools = await client.load_toolset("toolset_name")

For more detailed instructions on using the Toolbox Core SDK, see the project’s README.

LangChain / LangGraph

Install Toolbox LangChain SDK:
1

pip install toolbox-langchain

Load tools:

from toolbox_langchain import ToolboxClient

# update the url to point to your server
async with ToolboxClient("http://127.0.0.1:5000") as client:

    # these tools can be passed to your application!
    tools = client.load_toolset()

For more detailed instructions on using the Toolbox LangChain SDK, see the project’s README.

LlamaIndex

Install Toolbox Llamaindex SDK:
1

pip install toolbox-llamaindex

Load tools:

from toolbox_llamaindex import ToolboxClient

# update the url to point to your server
async with ToolboxClient("http://127.0.0.1:5000") as client:

    # these tools can be passed to your application!
    tools = client.load_toolset()

For more detailed instructions on using the Toolbox Llamaindex SDK, see the project’s README.

Javascript/Typescript (Github)

Core

Install Toolbox Core SDK:
1

npm install @toolbox-sdk/core

Load tools:

import { ToolboxClient } from '@toolbox-sdk/core';

// update the url to point to your server
const URL = 'http://127.0.0.1:5000';
let client = new ToolboxClient(URL);

// these tools can be passed to your application!
const tools = await client.loadToolset('toolsetName');

For more detailed instructions on using the Toolbox Core SDK, see the project’s README.

LangChain / LangGraph

Install Toolbox Core SDK:
1

npm install @toolbox-sdk/core

Load tools:

import { ToolboxClient } from '@toolbox-sdk/core';

// update the url to point to your server
const URL = 'http://127.0.0.1:5000';
let client = new ToolboxClient(URL);

// these tools can be passed to your application!
const toolboxTools = await client.loadToolset('toolsetName');

// Define the basics of the tool: name, description, schema and core logic
const getTool = (toolboxTool) => tool(currTool, {
    name: toolboxTool.getName(),
    description: toolboxTool.getDescription(),
    schema: toolboxTool.getParamSchema()
});

// Use these tools in your Langchain/Langraph applications
const tools = toolboxTools.map(getTool);

Genkit

Install Toolbox Core SDK:
1

npm install @toolbox-sdk/core

Load tools:

import { ToolboxClient } from '@toolbox-sdk/core';
import { genkit } from 'genkit';

// Initialise genkit
const ai = genkit({
    plugins: [
        googleAI({
            apiKey: process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY
        })
    ],
    model: googleAI.model('gemini-2.0-flash'),
});

// update the url to point to your server
const URL = 'http://127.0.0.1:5000';
let client = new ToolboxClient(URL);

// these tools can be passed to your application!
const toolboxTools = await client.loadToolset('toolsetName');

// Define the basics of the tool: name, description, schema and core logic
const getTool = (toolboxTool) => ai.defineTool({
    name: toolboxTool.getName(),
    description: toolboxTool.getDescription(),
    schema: toolboxTool.getParamSchema()
}, toolboxTool)

// Use these tools in your Genkit applications
const tools = toolboxTools.map(getTool);

Go (Github)

Core

Install Toolbox Go SDK:

`1`	`go get github.com/googleapis/mcp-toolbox-sdk-go`

Load tools:

package main

import (
  "github.com/googleapis/mcp-toolbox-sdk-go/core"
  "context"
)

func main() {
  // Make sure to add the error checks
  // update the url to point to your server
  URL := "http://127.0.0.1:5000";
  ctx := context.Background()

  client, err := core.NewToolboxClient(URL)

  // Framework agnostic tools
  tools, err := client.LoadToolset("toolsetName", ctx)
}

For more detailed instructions on using the Toolbox Go SDK, see the project’s README.

LangChain Go

Install Toolbox Go SDK:

`1`	`go get github.com/googleapis/mcp-toolbox-sdk-go`

Load tools:

package main

import (
  "context"
  "encoding/json"

  "github.com/googleapis/mcp-toolbox-sdk-go/core"
  "github.com/tmc/langchaingo/llms"
)

func main() {
  // Make sure to add the error checks
  // update the url to point to your server
  URL := "http://127.0.0.1:5000"
  ctx := context.Background()

  client, err := core.NewToolboxClient(URL)

  // Framework agnostic tool
  tool, err := client.LoadTool("toolName", ctx)

  // Fetch the tool's input schema
  inputschema, err := tool.InputSchema()

  var paramsSchema map[string]any
  _ = json.Unmarshal(inputschema, &paramsSchema)

  // Use this tool with LangChainGo
  langChainTool := llms.Tool{
    Type: "function",
    Function: &llms.FunctionDefinition{
      Name:        tool.Name(),
      Description: tool.Description(),
      Parameters:  paramsSchema,
    },
  }
}

Genkit

Install Toolbox Go SDK:

`1`	`go get github.com/googleapis/mcp-toolbox-sdk-go`

Load tools:

package main
import (
  "context"
  "encoding/json"

  "github.com/firebase/genkit/go/ai"
  "github.com/firebase/genkit/go/genkit"
  "github.com/googleapis/mcp-toolbox-sdk-go/core"
  "github.com/googleapis/mcp-toolbox-sdk-go/tbgenkit"
  "github.com/invopop/jsonschema"
)

func main() {
  // Make sure to add the error checks
  // Update the url to point to your server
  URL := "http://127.0.0.1:5000"
  ctx := context.Background()
  g, err := genkit.Init(ctx)

  client, err := core.NewToolboxClient(URL)

  // Framework agnostic tool
  tool, err := client.LoadTool("toolName", ctx)

  // Convert the tool using the tbgenkit package
  // Use this tool with Genkit Go
  genkitTool, err := tbgenkit.ToGenkitTool(tool, g)
  if err != nil {
    log.Fatalf("Failed to convert tool: %v\n", err)
  }
}

Go GenAI

Install Toolbox Go SDK:

`1`	`go get github.com/googleapis/mcp-toolbox-sdk-go`

Load tools:

package main

import (
  "context"
  "encoding/json"

  "github.com/googleapis/mcp-toolbox-sdk-go/core"
  "google.golang.org/genai"
)

func main() {
  // Make sure to add the error checks
  // Update the url to point to your server
  URL := "http://127.0.0.1:5000"
  ctx := context.Background()

  client, err := core.NewToolboxClient(URL)

  // Framework agnostic tool
  tool, err := client.LoadTool("toolName", ctx)

  // Fetch the tool's input schema
  inputschema, err := tool.InputSchema()

  var schema *genai.Schema
  _ = json.Unmarshal(inputschema, &schema)

  funcDeclaration := &genai.FunctionDeclaration{
    Name:        tool.Name(),
    Description: tool.Description(),
    Parameters:  schema,
  }

  // Use this tool with Go GenAI
  genAITool := &genai.Tool{
    FunctionDeclarations: []*genai.FunctionDeclaration{funcDeclaration},
  }
}

OpenAI Go

Install Toolbox Go SDK:

`1`	`go get github.com/googleapis/mcp-toolbox-sdk-go`

Load tools:

package main

import (
  "context"
  "encoding/json"

  "github.com/googleapis/mcp-toolbox-sdk-go/core"
  openai "github.com/openai/openai-go"
)

func main() {
  // Make sure to add the error checks
  // Update the url to point to your server
  URL := "http://127.0.0.1:5000"
  ctx := context.Background()

  client, err := core.NewToolboxClient(URL)

  // Framework agnostic tool
  tool, err := client.LoadTool("toolName", ctx)

  // Fetch the tool's input schema
  inputschema, err := tool.InputSchema()

  var paramsSchema openai.FunctionParameters
  _ = json.Unmarshal(inputschema, &paramsSchema)

  // Use this tool with OpenAI Go
  openAITool := openai.ChatCompletionToolParam{
    Function: openai.FunctionDefinitionParam{
      Name:        tool.Name(),
      Description: openai.String(tool.Description()),
      Parameters:  paramsSchema,
    },
  }

}

Configuration

The primary way to configure Toolbox is through the tools.yaml file. If you have multiple files, you can tell toolbox which to load with the --tools-file tools.yaml flag.

You can find more detailed reference documentation to all resource types in the Resources.

Sources

The sources section of your tools.yaml defines what data sources your Toolbox should have access to. Most tools will have at least one source to execute against.

sources:
  my-pg-source:
    kind: postgres
    host: 127.0.0.1
    port: 5432
    database: toolbox_db
    user: toolbox_user
    password: my-password

For more details on configuring different types of sources, see the Sources.

Tools

The tools section of a tools.yaml define the actions an agent can take: what kind of tool it is, which source(s) it affects, what parameters it uses, etc.

tools:
  search-hotels-by-name:
    kind: postgres-sql
    source: my-pg-source
    description: Search for hotels based on name.
    parameters:
      - name: name
        type: string
        description: The name of the hotel.
    statement: SELECT * FROM hotels WHERE name ILIKE '%' || $1 || '%';

For more details on configuring different types of tools, see the Tools.

Toolsets

The toolsets section of your tools.yaml allows you to define groups of tools that you want to be able to load together. This can be useful for defining different groups based on agent or application.

toolsets:
    my_first_toolset:
        - my_first_tool
        - my_second_tool
    my_second_toolset:
        - my_second_tool
        - my_third_tool

You can load toolsets by name:

# This will load all tools
all_tools = client.load_toolset()

# This will only load the tools listed in 'my_second_toolset'
my_second_toolset = client.load_toolset("my_second_toolset")

Versioning

This project uses semantic versioning (MAJOR.MINOR.PATCH). Since the project is in a pre-release stage (version 0.x.y), we follow the standard conventions for initial development:

Pre-1.0.0 Versioning

While the major version is 0, the public API should be considered unstable. The version will be incremented as follows:

0.MINOR.PATCH: The MINOR version is incremented when we add new functionality or make breaking, incompatible API changes.
0.MINOR.PATCH: The PATCH version is incremented for backward-compatible bug fixes.

Post-1.0.0 Versioning

Once the project reaches a stable 1.0.0 release, the versioning will follow the more common convention:

MAJOR.MINOR.PATCH: Incremented for incompatible API changes.
MAJOR.MINOR.PATCH: Incremented for new, backward-compatible functionality.
MAJOR.MINOR.PATCH: Incremented for backward-compatible bug fixes.

The public API that this applies to is the CLI associated with Toolbox, the interactions with official SDKs, and the definitions in the tools.yaml file.

Contributing

Contributions are welcome. Please, see the CONTRIBUTING to get started.

Please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms. See Contributor Code of Conduct for more information.

Community

Join our discord community to connect with our developers!

GenAI_Agents

Wed, 09 Jul 2025 15:32:24 +0800

NirDiamant/GenAI_Agents

🌟 Support This Project: Your sponsorship fuels innovation in GenAI agent development. Become a sponsor to help maintain and expand this valuable resource!

GenAI Agents: Comprehensive Repository for Development and Implementation 🚀

Welcome to one of the most extensive and dynamic collections of Generative AI (GenAI) agent tutorials and implementations available today. This repository serves as a comprehensive resource for learning, building, and sharing GenAI agents, ranging from simple conversational bots to complex, multi-agent systems.

📫 Stay Updated!

🚀
Cutting-edge
Updates

💡
Expert
Insights

🎯
Top 0.1%
Content

Join over 20,000 of AI enthusiasts getting unique cutting-edge insights and free tutorials! Plus, subscribers get exclusive early access and special 33% discounts to my book and the upcoming RAG Techniques course!

Introduction

Generative AI agents are at the forefront of artificial intelligence, revolutionizing the way we interact with and leverage AI technologies. This repository is designed to guide you through the development journey, from basic agent implementations to advanced, cutting-edge systems.

📚 Learn to Build Your First AI Agent

Your First AI Agent: Simpler Than You Think

This detailed blog post complements the repository by providing a complete A-Z walkthrough with in-depth explanations of core concepts, step-by-step implementation, and the theory behind AI agents. It's designed to be incredibly simple to follow while covering everything you need to know to build your first working agent from scratch.

💡 Plus: Subscribe to the newsletter for exclusive early access to tutorials and special discounts on upcoming courses and books!

Our goal is to provide a valuable resource for everyone - from beginners taking their first steps in AI to seasoned practitioners pushing the boundaries of what’s possible. By offering a range of examples from foundational to complex, we aim to facilitate learning, experimentation, and innovation in the rapidly evolving field of GenAI agents.

Furthermore, this repository serves as a platform for showcasing innovative agent creations. Whether you’ve developed a novel agent architecture or found an innovative application for existing techniques, we encourage you to share your work with the community.

🚀 Level up with my Agents Towards Production repository. It delivers horizontal, code-first tutorials that cover every tool and step in the lifecycle of building production-grade GenAI agents, guiding you from spark to scale with proven patterns and reusable blueprints for real-world launches, making it the smartest place to start if you’re serious about shipping agents to production.

📚 Dive into my comprehensive guide on RAG techniques to learn about integrating external knowledge into AI systems, enhancing their capabilities with up-to-date and relevant information retrieval.

🖋️ Explore my Prompt Engineering Techniques guide for an extensive collection of prompting strategies, from fundamental concepts to advanced methods, improving your ability to communicate effectively with AI language models.

A Community-Driven Knowledge Hub

This repository grows stronger with your contributions! Join our vibrant Discord community — the central hub for shaping and advancing this project together 🤝

GenAI Agents Discord Community

Whether you’re a novice eager to learn or an expert ready to share your knowledge, your insights can shape the future of GenAI agents. Join us to propose ideas, get feedback, and collaborate on innovative implementations. For contribution guidelines, please refer to our CONTRIBUTING.md file. Let’s advance GenAI agent technology together!

🔗 For discussions on GenAI, agents, or to explore knowledge-sharing opportunities, feel free to connect on LinkedIn.

Key Features

🎓 Learn to build GenAI agents from beginner to advanced levels
🧠 Explore a wide range of agent architectures and applications
📚 Step-by-step tutorials and comprehensive documentation
🛠️ Practical, ready-to-use agent implementations
🌟 Regular updates with the latest advancements in GenAI
🤝 Share your own agent creations with the community

GenAI Agent Implementations

Below is a comprehensive overview of our GenAI agent implementations, organized by category and functionality. Each implementation is designed to showcase different aspects of AI agent development, from basic conversational agents to complex multi-agent systems.

#	Category	Agent Name	Framework	Key Features
1	🌱 Beginner	Simple Conversational Agent	LangChain/PydanticAI	Context-aware conversations, history management
2	🌱 Beginner	Simple Question Answering	LangChain	Query understanding, concise answers
3	🌱 Beginner	Simple Data Analysis	LangChain/PydanticAI	Dataset interpretation, natural language queries
4	🔧 Framework	Introduction to LangGraph	LangGraph	Modular AI workflows, state management
5	🔧 Framework	Model Context Protocol (MCP)	MCP	AI-external resource integration
6	🎓 Educational	ATLAS: Academic Task System	LangGraph	Multi-agent academic planning, note-taking
7	🎓 Educational	Scientific Paper Agent	LangGraph	Literature review automation
8	🎓 Educational	Chiron - Feynman Learning	LangGraph	Adaptive learning, checkpoint system
9	💼 Business	Customer Support Agent	LangGraph	Query categorization, sentiment analysis
10	💼 Business	Essay Grading Agent	LangGraph	Automated grading, multiple criteria
11	💼 Business	Travel Planning Agent	LangGraph	Personalized itineraries
12	💼 Business	GenAI Career Assistant	LangGraph	Career guidance, learning paths
13	💼 Business	Project Manager Assistant	LangGraph	Task generation, risk assessment
14	💼 Business	Contract Analysis Assistant	LangGraph	Clause analysis, compliance checking
15	💼 Business	E2E Testing Agent	LangGraph	Test automation, browser control
16	🎨 Creative	GIF Animation Generator	LangGraph	Text-to-animation pipeline
17	🎨 Creative	TTS Poem Generator	LangGraph	Text classification, speech synthesis
18	🎨 Creative	Music Compositor	LangGraph	AI music composition
19	🎨 Creative	Content Intelligence	LangGraph	Multi-platform content generation
20	🎨 Creative	Business Meme Generator	LangGraph	Brand-aligned meme creation
21	🎨 Creative	Murder Mystery Game	LangGraph	Procedural story generation
22	📊 Analysis	Memory-Enhanced Conversational	LangChain	Short/long-term memory integration
23	📊 Analysis	Multi-Agent Collaboration	LangChain	Historical research, data analysis
24	📊 Analysis	Self-Improving Agent	LangChain	Learning from interactions
25	📊 Analysis	Task-Oriented Agent	LangChain	Text summarization, translation
26	📊 Analysis	Internet Search Agent	LangChain	Web research, summarization
27	📊 Analysis	Research Team - Autogen	AutoGen	Multi-agent research collaboration
28	📊 Analysis	Sales Call Analyzer	LangGraph	Audio transcription, NLP analysis
29	📊 Analysis	Weather Emergency System	LangGraph	Real-time data processing
30	📊 Analysis	Self-Healing Codebase	LangGraph	Error detection, automated fixes
31	📊 Analysis	DataScribe	LangGraph	Database exploration, query planning
32	📊 Analysis	Memory-Enhanced Email	LangGraph	Email triage, response generation
33	📰 News	News TL;DR	LangGraph	News summarization, API integration
34	📰 News	AInsight	LangGraph	AI/ML news aggregation
35	📰 News	Journalism Assistant	LangGraph	Fact-checking, bias detection
36	📰 News	Blog Writer	OpenAI Swarm	Collaborative content creation
37	📰 News	Podcast Generator	LangGraph	Content search, audio generation
38	🛍️ Shopping	ShopGenie	LangGraph	Product comparison, recommendations
39	🛍️ Shopping	Car Buyer Agent	LangGraph	Web scraping, decision support
40	🎯 Task Management	Taskifier	LangGraph	Work style analysis, task breakdown
41	🎯 Task Management	Grocery Management	CrewAI	Inventory tracking, recipe suggestions
42	🔍 QA	LangGraph Inspector	LangGraph	System testing, vulnerability detection
43	🔍 QA	EU Green Deal Bot	LangGraph	Regulatory compliance, FAQ system
44	🔍 QA	Systematic Review	LangGraph	Academic paper processing, draft generation
45	🌟 Advanced	Controllable RAG Agent	Custom	Complex question answering, deterministic graph

Explore our extensive list of GenAI agent implementations, sorted by categories:

🌱 Beginner-Friendly Agents

Simple Conversational Agent
- LangChain
- PydanticAI
Overview 🔎
A context-aware conversational AI maintains information across interactions, enabling more natural dialogues.

Implementation 🛠️
Integrates a language model, prompt template, and history manager to generate contextual responses and track conversation sessions.
Simple Question Answering Agent

Overview 🔎
Answering (QA) agent using LangChain and OpenAI’s language model understands user queries and provides relevant, concise answers.

Implementation 🛠️
Combines OpenAI’s GPT model, a prompt template, and an LLMChain to process user questions and generate AI-driven responses in a streamlined manner.
Simple Data Analysis Agent
- LangChain
- PydanticAI
Overview 🔎
An AI-powered data analysis agent interprets and answers questions about datasets using natural language, combining language models with data manipulation tools for intuitive data exploration.

Implementation 🛠️
Integrates a language model, data manipulation framework, and agent framework to process natural language queries and perform data analysis on a synthetic dataset, enabling accessible insights for non-technical users.

🔧 Framework Tutorial

Introduction to LangGraph: Building Modular AI Workflows

Overview 🔎
This tutorial introduces LangGraph, a powerful framework for creating modular, graph-based AI workflows. Learn how to leverage LangGraph to build more complex and flexible AI agents that can handle multi-step processes efficiently.

Implementation 🛠️
Step-by-step guide on using LangGraph to create a StateGraph workflow. The tutorial covers key concepts such as state management, node creation, and graph compilation. It demonstrates these principles by constructing a simple text analysis pipeline, serving as a foundation for more advanced agent architectures.

Additional Resources 📚
- Blog Post
Model Context Protocol (MCP): Seamless Integration of AI and External Resources

Overview 🔎
This tutorial introduces the Model Context Protocol (MCP), an open standard for connecting AI models with external data sources and tools. Learn how MCP serves as a universal bridge between GenAI agents and the wider digital ecosystem, enabling more capable and context-aware AI applications.

Implementation 🛠️
Provides a hands-on guide to implementing MCP servers and clients, demonstrating how to connect language models with external tools and data sources. The tutorial covers server setup, tool definition, and integration with AI clients, with practical examples of building useful agent capabilities through the protocol.

Additional Resources 📚
- Blog Post
- Official MCP Documentation
- MCP GitHub Repository

🎓 Educational and Research Agents

ATLAS: Academic Task and Learning Agent System

Overview 🔎
ATLAS demonstrates how to build an intelligent multi-agent system that transforms academic support through AI-powered assistance. The system leverages LangGraph’s workflow framework to coordinate multiple specialized agents that provide personalized academic planning, note-taking, and advisory support.

Implementation 🛠️
Implements a state-managed multi-agent architecture using four specialized agents (Coordinator, Planner, Notewriter, and Advisor) working in concert through LangGraph’s workflow framework. The system features sophisticated workflows for profile analysis and academic support, with continuous adaptation based on student performance and feedback.

Additional Resources 📚
- YouTube Explanation
- Blog Post
Scientific Paper Agent - Literature Review

Overview 🔎
An intelligent research assistant that helps users navigate, understand, and analyze scientific literature through an orchestrated workflow. The system combines academic APIs with sophisticated paper processing techniques to automate literature review tasks, enabling researchers to efficiently extract insights from academic papers while maintaining research rigor and quality control.

Implementation 🛠️
Leverages LangGraph to create a five-node workflow system including decision making, planning, tool execution, and quality validation nodes. The system integrates the CORE API for paper access, PDFplumber for document processing, and advanced language models for analysis. Key features include a retry mechanism for robust paper downloads, structured data handling through Pydantic models, and quality-focused improvement cycles with human-in-the-loop validation options.

Additional Resources 📚
- YouTube Explanation
- Blog Post
Chiron - A Feynman-Enhanced Learning Agent

Overview 🔎
An adaptive learning agent that guides users through educational content using a structured checkpoint system and Feynman-style teaching. The system processes learning materials (either user-provided or web-retrieved), verifies understanding through interactive checkpoints, and provides simplified explanations when needed, creating a personalized learning experience that mimics one-on-one tutoring.

Implementation 🛠️
Uses LangGraph to orchestrate a learning workflow that includes checkpoint definition, context building, understanding verification, and Feynman teaching nodes. The system integrates web search for dynamic content retrieval, employs semantic chunking for context processing, and manages embeddings for relevant information retrieval. Key features include a 70% understanding threshold for progression, interactive human-in-the-loop validation, and structured output through Pydantic models for consistent data handling.

Additional Resources 📚
- YouTube Explanation

💼 Business and Professional Agents

Customer Support Agent (LangGraph)

Overview 🔎
An intelligent customer support agent using LangGraph categorizes queries, analyzes sentiment, and provides appropriate responses or escalates issues.

Implementation 🛠️
Utilizes LangGraph to create a workflow combining state management, query categorization, sentiment analysis, and response generation.
Essay Grading Agent (LangGraph)

Overview 🔎
An automated essay grading system using LangGraph and an LLM model evaluates essays based on relevance, grammar, structure, and depth of analysis.

Implementation 🛠️
Utilizes a state graph to define the grading workflow, incorporating separate grading functions for each criterion.
Travel Planning Agent (LangGraph)

Overview 🔎
A Travel Planner using LangGraph demonstrates how to build a stateful, multi-step conversational AI application that collects user input and generates personalized travel itineraries.

Implementation 🛠️
Utilizes StateGraph to define the application flow, incorporates custom PlannerState for process management.
GenAI Career Assistant Agent

Overview 🔎
The GenAI Career Assistant demonstrates how to create a multi-agent system that provides personalized guidance for careers in Generative AI. Using LangGraph and Gemini LLM, the system delivers customized learning paths, resume assistance, interview preparation, and job search support.

Implementation 🛠️
Leverages a multi-agent architecture using LangGraph to coordinate specialized agents (Learning, Resume, Interview, Job Search) through TypedDict-based state management. The system employs sophisticated query categorization and routing while integrating with external tools like DuckDuckGo for job searches and dynamic content generation.

Additional Resources 📚
- YouTube Explanation
Project Manager Assistant Agent

Overview 🔎
An AI agent designed to assist in project management tasks by automating the process of creating actionable tasks from project descriptions, identifying dependencies, scheduling work, and assigning tasks to team members based on expertise. The system includes risk assessment and self-reflection capabilities to optimize project plans through multiple iterations, aiming to minimize overall project risk.

Implementation 🛠️
Leverages LangGraph to orchestrate a workflow of specialized nodes including task generation, dependency mapping, scheduling, allocation, and risk assessment. Each node uses GPT-4o-mini for structured outputs following Pydantic models. The system implements a feedback loop for self-improvement, where risk scores trigger reflection cycles that generate insights to optimize the project plan. Visualization tools display Gantt charts of the generated schedules across iterations.

Additional Resources 📚
- YouTube Explanation
Contract Analysis Assistant (ClauseAI)

Overview 🔎
ClauseAI demonstrates how to build an AI-powered contract analysis system using a multi-agent approach. The system employs specialized AI agents for different aspects of contract review, from clause analysis to compliance checking, and leverages LangGraph for workflow orchestration and Pinecone for efficient clause retrieval and comparison.

Implementation 🛠️
Implements a sophisticated state-based workflow using LangGraph to coordinate multiple AI agents through contract analysis stages. The system features Pydantic models for data validation, vector storage with Pinecone for clause comparison, and LLM-based analysis for generating comprehensive contract reports. The implementation includes parallel processing capabilities and customizable report generation based on user requirements.

Additional Resources 📚
- YouTube Explanation
E2E Testing Agent

Overview 🔎
The E2E Testing Agent demonstrates how to build an AI-powered system that converts natural language test instructions into executable end-to-end web tests. Using LangGraph for workflow orchestration and Playwright for browser automation, the system enables users to specify test cases in plain English while handling the complexity of test generation and execution.

Implementation 🛠️
Implements a structured workflow using LangGraph to coordinate test generation, validation, and execution. The system features TypedDict state management, integration with Playwright for browser automation, and LLM-based code generation for converting natural language instructions into executable test scripts. The implementation includes DOM state analysis, error handling, and comprehensive test reporting.

Additional Resources 📚
- YouTube Explanation

🎨 Creative and Content Generation Agents

GIF Animation Generator Agent (LangGraph)

Overview 🔎
A GIF animation generator that integrates LangGraph for workflow management, GPT-4 for text generation, and DALL-E for image creation, producing custom animations from user prompts.

Implementation 🛠️
Utilizes LangGraph to orchestrate a workflow that generates character descriptions, plots, and image prompts using GPT-4, creates images with DALL-E 3, and assembles them into GIFs using PIL. Employs asynchronous programming for efficient parallel processing.
TTS Poem Generator Agent (LangGraph)

Overview 🔎
An advanced text-to-speech (TTS) agent using LangGraph and OpenAI’s APIs classifies input text, processes it based on content type, and generates corresponding speech output.

Implementation 🛠️
Utilizes LangGraph to orchestrate a workflow that classifies input text using GPT models, applies content-specific processing, and converts the processed text to speech using OpenAI’s TTS API. The system adapts its output based on the identified content type (general, poem, news, or joke).
Music Compositor Agent (LangGraph)

Overview 🔎
An AI Music Compositor using LangGraph and OpenAI’s language models generates custom musical compositions based on user input. The system processes the input through specialized components, each contributing to the final musical piece, which is then converted to a playable MIDI file.

Implementation 🛠️
LangGraph orchestrates a workflow that transforms user input into a musical composition, using ChatOpenAI (GPT-4) to generate melody, harmony, and rhythm, which are then style-adapted. The final AI-generated composition is converted to a MIDI file using music21 and can be played back using pygame.
Content Intelligence: Multi-Platform Content Generation Agent

Overview 🔎
Content Intelligence demonstrates how to build an advanced content generation system that transforms input text into platform-optimized content across multiple social media channels. The system employs LangGraph for workflow orchestration to analyze content, conduct research, and generate tailored content while maintaining brand consistency across different platforms.

Implementation 🛠️
Implements a sophisticated workflow using LangGraph to coordinate multiple specialized nodes (Summary, Research, Platform-Specific) through the content generation process. The system features TypedDict and Pydantic models for state management, integration with Tavily Search for research enhancement, and platform-specific content generation using GPT-4. The implementation includes parallel processing for multiple platforms and customizable content templates.

Additional Resources 📚
- YouTube Explanation
Business Meme Generator Using LangGraph and Memegen.link

Overview 🔎
The Business Meme Generator demonstrates how to create an AI-powered system that generates contextually relevant memes based on company website analysis. Using LangGraph for workflow orchestration, the system combines Groq’s Llama model for text analysis and the Memegen.link API to automatically produce brand-aligned memes for digital marketing.

Implementation 🛠️
Implements a state-managed workflow using LangGraph to coordinate website content analysis, meme concept generation, and image creation. The system features Pydantic models for data validation, asynchronous processing with aiohttp, and integration with external APIs (Groq, Memegen.link) to create a complete meme generation pipeline with customizable templates.

Additional Resources 📚
- YouTube Explanation
Murder Mystery Game with LLM Agents

Overview 🔎
A text-based detective game that utilizes autonomous LLM agents as interactive characters in a procedurally generated murder mystery. Drawing inspiration from the UNBOUNDED paper, the system creates unique scenarios each time, with players taking on the role of Sherlock Holmes to solve the case through character interviews and deductive reasoning.

Implementation 🛠️
Leverages two LangGraph workflows - a main game loop for story/character generation and game progression, and a conversation sub-graph for character interactions. The system uses a combination of LLM-powered narrative generation, character AI, and structured game mechanics to create an immersive investigative experience with replayable storylines.

Additional Resources 📚
- YouTube Explanation

📊 Analysis and Information Processing Agents

Memory-Enhanced Conversational Agent

Overview 🔎
A memory-enhanced conversational AI agent incorporates short-term and long-term memory systems to maintain context within conversations and across multiple sessions, improving interaction quality and personalization.

Implementation 🛠️
Integrates a language model with separate short-term and long-term memory stores, utilizes a prompt template incorporating both memory types, and employs a memory manager for storage and retrieval. The system includes an interaction loop that updates and utilizes memories for each response.
Multi-Agent Collaboration System

Overview 🔎
A multi-agent collaboration system combining historical research with data analysis, leveraging large language models to simulate specialized agents working together to answer complex historical questions.

Implementation 🛠️
Utilizes a base Agent class to create specialized HistoryResearchAgent and DataAnalysisAgent, orchestrated by a HistoryDataCollaborationSystem. The system follows a five-step process: historical context provision, data needs identification, historical data provision, data analysis, and final synthesis.
Self-Improving Agent

Overview 🔎
A Self-Improving Agent using LangChain engages in conversations, learns from interactions, and continuously improves its performance over time through reflection and adaptation.

Implementation 🛠️
Integrates a language model with chat history management, response generation, and a reflection mechanism. The system employs a learning system that incorporates insights from reflection to enhance future performance, creating a continuous improvement loop.
Task-Oriented Agent

Overview 🔎
A language model application using LangChain that summarizes text and translates the summary to Spanish, combining custom functions, structured tools, and an agent for efficient text processing.

Implementation 🛠️
Utilizes custom functions for summarization and translation, wrapped as structured tools. Employs a prompt template to guide the agent, which orchestrates the use of tools. An agent executor manages the process, taking input text and producing both an English summary and its Spanish translation.
Internet Search and Summarize Agent

Overview 🔎
An intelligent web research assistant that combines web search capabilities with AI-powered summarization, automating the process of gathering information from the internet and distilling it into concise, relevant summaries.

Implementation 🛠️
Integrates a web search module using DuckDuckGo’s API, a result parser, and a text summarization engine leveraging OpenAI’s language models. The system performs site-specific or general searches, extracts relevant content, generates concise summaries, and compiles attributed results for efficient information retrieval and synthesis.
Multi agent research team - Autogen

Overview 🔎
This technique explores a multi-agent system for collaborative research using the AutoGen library. It employs agents to solve tasks collaboratively, focusing on efficient execution and quality assurance. The system enhances research by distributing tasks among specialized agents.

Implementation 🛠️
Agents are configured with specific roles using the GPT-4 model, including admin, developer, planner, executor, and quality assurance. Interaction management ensures orderly communication with defined transitions. Task execution involves collaborative planning, coding, execution, and quality checking, demonstrating a scalable framework for various domains.

Additional Resources 📚
- comprehensive solution with UI
- Blogpost
Sales Call Analyzer

Overview 🔎
An intelligent system that automates the analysis of sales call recordings by combining audio transcription with advanced natural language processing. The analyzer transcribes audio using OpenAI’s Whisper, processes the text using NLP techniques, and generates comprehensive reports including sentiment analysis, key phrases, pain points, and actionable recommendations to improve sales performance.

Implementation 🛠️
Utilizes multiple components in a structured workflow: OpenAI Whisper for audio transcription, CrewAI for task automation and agent management, and LangChain for orchestrating the analysis pipeline. The system processes audio through a series of steps from transcription to detailed analysis, leveraging custom agents and tasks to generate structured JSON reports containing insights about customer sentiment, sales opportunities, and recommended improvements.

Additional Resources 📚
- YouTube Explanation
Weather Emergency & Response System

Overview 🔎
A comprehensive system demonstrating two agent graph implementations for weather emergency response: a real-time graph processing live weather data, and a hybrid graph combining real and simulated data for testing high-severity scenarios. The system handles complete workflow from data gathering through emergency plan generation, with automated notifications and human verification steps.

Implementation 🛠️
Utilizes LangGraph for orchestrating complex workflows with state management, integrating OpenWeatherMap API for real-time data, and Gemini for analysis and response generation. The system incorporates email notifications, social media monitoring simulation, and severity-based routing with configurable human verification for low/medium severity events.

Additional Resources 📚
- YouTube Explanation
Self-Healing Codebase System

Overview 🔎
An intelligent system that automatically detects, diagnoses, and fixes runtime code errors using LangGraph workflow orchestration and ChromaDB vector storage. The system maintains a memory of encountered bugs and their fixes through vector embeddings, enabling pattern recognition for similar errors across the codebase.

Implementation 🛠️
Utilizes a state-based graph workflow that processes function definitions and runtime arguments through specialized nodes for error detection, code analysis, and fix generation. Incorporates ChromaDB for vector-based storage of bug patterns and fixes, with automated search and retrieval capabilities for similar error patterns, while maintaining code execution safety through structured validation steps.

Additional Resources 📚
- YouTube Explanation
DataScribe: AI-Powered Schema Explorer

Overview 🔎
An intelligent agent system that enables intuitive exploration and querying of relational databases through natural language interactions. The system utilizes a fleet of specialized agents, coordinated by a stateful Supervisor, to handle schema discovery, query planning, and data analysis tasks while maintaining contextual understanding through vector-based relationship graphs.

Implementation 🛠️
Leverages LangGraph for orchestrating a multi-agent workflow including discovery, inference, and planning agents, with NetworkX for relationship graph visualization and management. The system incorporates dynamic state management through TypedDict classes, maintains database context between sessions using a db_graph attribute, and includes safety measures to prevent unauthorized database modifications.
Memory-Enhanced Email Agent (LangGraph & LangMem)

Overview 🔎
An intelligent email assistant that combines three types of memory (semantic, episodic, and procedural) to create a system that improves over time. The agent can triage incoming emails, draft contextually appropriate responses using stored knowledge, and enhance its performance based on user feedback.

Implementation 🛠️
Leverages LangGraph for workflow orchestration and LangMem for sophisticated memory management across multiple memory types. The system implements a triage workflow with memory-enhanced decision making, specialized tools for email composition and calendar management, and a self-improvement mechanism that updates its own prompts based on feedback and past performance.

Additional Resources 📚
- **Blog Post

📰 News and Information Agents

News TL;DR using LangGraph

Overview 🔎
A news summarization system that generates concise TL;DR summaries of current events based on user queries. The system leverages large language models for decision making and summarization while integrating with news APIs to access up-to-date content, allowing users to quickly catch up on topics of interest through generated bullet-point summaries.

Implementation 🛠️
Utilizes LangGraph to orchestrate a workflow combining multiple components: GPT-4o-mini for generating search terms and article summaries, NewsAPI for retrieving article metadata, BeautifulSoup for web scraping article content, and Asyncio for concurrent processing. The system follows a structured pipeline from query processing through article selection and summarization, managing the flow between components to produce relevant TL;DRs of current news articles.

Additional Resources 📚
- YouTube Explanation
- Blog Post
AInsight: AI/ML Weekly News Reporter

Overview 🔎
AInsight demonstrates how to build an intelligent news aggregation and summarization system using a multi-agent architecture. The system employs three specialized agents (NewsSearcher, Summarizer, Publisher) to automatically collect, process and summarize AI/ML news for general audiences through LangGraph-based workflow orchestration.

Implementation 🛠️
Implements a state-managed multi-agent system using LangGraph to coordinate the news collection (Tavily API), technical content summarization (GPT-4), and report generation processes. The system features modular architecture with TypedDict-based state management, external API integration, and markdown report generation with customizable templates.

Additional Resources 📚
- YouTube Explanation
Journalism-Focused AI Assistant

Overview 🔎
A specialized AI assistant that helps journalists tackle modern journalistic challenges like misinformation, bias, and information overload. The system integrates fact-checking, tone analysis, summarization, and grammar review tools to enhance the accuracy and efficiency of journalistic work while maintaining ethical reporting standards.

Implementation 🛠️
Leverages LangGraph to orchestrate a workflow of specialized components including language models for analysis and generation, web search integration via DuckDuckGo’s API, document parsing tools like PyMuPDFLoader and WebBaseLoader, text splitting with RecursiveCharacterTextSplitter, and structured JSON outputs. Each component works together through a unified workflow to analyze content, verify facts, detect bias, extract quotes, and generate comprehensive reports.
Blog Writer (Open AI Swarm)

Overview 🔎
A multi-agent system for collaborative blog post creation using OpenAI’s Swarm package. It leverages specialized agents to perform research, planning, writing, and editing tasks efficiently.

Implementation 🛠️
Utilizes OpenAI’s Swarm Package to manage agent interactions. Includes an admin, researcher, planner, writer, and editor, each with specific roles. The system follows a structured workflow: topic setting, outlining, research, drafting, and editing. This approach enhances content creation through task distribution, specialization, and collaborative problem-solving.

Additional Resources 📚
- Swarm Repo
Podcast Internet Search and Generate Agent 🎙️

Overview 🔎
A two step agent that first searches the internet for a given topic and then generates a podcast on the topic found. The search step uses a search agent and search function to find the most relevant information. The second step uses a podcast generation agent and generation function to create a podcast on the topic found.

Implementation 🛠️
Utilizes LangGraph to orchestrate a two-step workflow. The first step involves a search agent and function to gather information from the internet. The second step uses a podcast generation agent and function to create a podcast based on the gathered information.

🛍️ Shopping and Product Analysis Agents

ShopGenie - Redefining Online Shopping Customer Experience

Overview 🔎
An AI-powered shopping assistant that helps customers make informed purchasing decisions even without domain expertise. The system analyzes product information from multiple sources, compares specifications and reviews, identifies the best option based on user needs, and delivers recommendations through email with supporting video reviews, creating a comprehensive shopping experience.

Implementation 🛠️
Uses LangGraph to orchestrate a workflow combining Tavily for web search, Llama-3.1-70B for structured data analysis and product comparison, and YouTube API for review video retrieval. The system processes search results through multiple nodes including schema mapping, product comparison, review identification, and email generation. Key features include structured Pydantic models for consistent data handling, retry mechanisms for robust API interactions, and email delivery through SMTP for sharing recommendations.

Additional Resources 📚
- YouTube Explanation
Car Buyer AI Agent

Overview 🔎
The Smart Product Buyer AI Agent demonstrates how to build an intelligent system that assists users in making informed purchasing decisions. Using LangGraph and LLM-based intelligence, the system processes user requirements, scrapes product listings from websites like AutoTrader, and provides detailed analysis and recommendations for car purchases.

Implementation 🛠️
Implements a state-based workflow using LangGraph to coordinate user interaction, web scraping, and decision support. The system features TypedDict state management, async web scraping with Playwright, and integrates with external APIs for comprehensive product analysis. The implementation includes a Gradio interface for real-time chat interaction and modular scraper architecture for easy extension to additional product categories.

Additional Resources 📚
- YouTube Explanation

🎯 Task Management and Productivity Agents

Taskifier - Intelligent Task Allocation & Management

Overview 🔎
An intelligent task management system that analyzes user work styles and creates personalized task breakdown strategies, born from the observation that procrastination often stems from task ambiguity among students and early-career professionals. The system evaluates historical work patterns, gathers relevant task information through web search, and generates customized step-by-step approaches to optimize productivity and reduce workflow paralysis.

Implementation 🛠️
Leverages LangGraph for orchestrating a multi-step workflow including work style analysis, information gathering via Tavily API, and customized plan generation. The system maintains state through the process, integrating historical work pattern data with fresh task research to output detailed, personalized task execution plans aligned with the user’s natural working style.

Additional Resources 📚
- YouTube Explanation
Grocery Management Agents System

Overview 🔎
A multi-agent system built with CrewAI that automates grocery management tasks including receipt interpretation, expiration date tracking, inventory management, and recipe recommendations. The system uses specialized agents to extract data from receipts, estimate product shelf life, track consumption, and suggest recipes to minimize food waste.

Implementation 🛠️
Implements four specialized agents using CrewAI - a Receipt Interpreter that extracts item details from receipts, an Expiration Date Estimator that determines shelf life using online sources, a Grocery Tracker that maintains inventory based on consumption, and a Recipe Recommender that suggests meals using available ingredients. Each agent has specific tools and tasks orchestrated through a crew workflow.

Additional Resources 📚
- YouTube Explanation

🔍 Quality Assurance and Testing Agents

LangGraph-Based Systems Inspector

Overview 🔎
A comprehensive testing and validation tool for LangGraph-based applications that automatically analyzes system architecture, generates test cases, and identifies potential vulnerabilities through multi-agent inspection. The inspector employs specialized AI testers to evaluate different aspects of the system, from basic functionality to security concerns and edge cases.

Implementation 🛠️
Integrates LangGraph for workflow orchestration, multiple LLM-powered testing agents, and a structured evaluation pipeline that includes static analysis, test case generation, and results verification. The system uses Pydantic for data validation, NetworkX for graph representation, and implements a modular architecture that allows for parallel test execution and comprehensive result analysis.

Additional Resources 📚
- YouTube Explanation
- Blog Post
EU Green Deal FAQ Bot

Overview 🔎
The EU Green Deal FAQ Bot demonstrates how to build a RAG-based AI agent that helps businesses understand EU green deal policies. The system processes complex regulatory documents into manageable chunks and provides instant, accurate answers to common questions about environmental compliance, emissions reporting, and waste management requirements.

Implementation 🛠️
Implements a sophisticated RAG pipeline using FAISS vectorstore for document storage, semantic chunking for preprocessing, and multiple specialized agents (Retriever, Summarizer, Evaluator) for query processing. The system features query rephrasing for improved accuracy, cross-reference with gold Q&A datasets for answer validation, and comprehensive evaluation metrics to ensure response quality and relevance.

Additional Resources 📚
- YouTube Explanation
Systematic Review Automation System + Paper Draft Creation

Overview 🔎
A comprehensive system for automating academic systematic reviews using a directed graph architecture and LangChain components. The system generates complete, publication-ready systematic review papers, automatically processing everything from literature search through final draft generation with multiple revision cycles.

Implementation 🛠️
Utilizes a state-based graph workflow that handles paper search and selection (up to 3 papers), PDF processing, and generates a complete academic paper with all standard sections (abstract, introduction, methods, results, conclusions, references). The system incorporates multiple revision cycles with automated critique and improvement phases, all orchestrated through LangGraph state management.

Additional Resources 📚
- YouTube Explanation

🌟 Special Advanced Technique 🌟

Sophisticated Controllable Agent for Complex RAG Tasks 🤖

Overview 🔎
An advanced RAG solution designed to tackle complex questions that simple semantic similarity-based retrieval cannot solve. This approach uses a sophisticated deterministic graph as the “brain” 🧠 of a highly controllable autonomous agent, capable of answering non-trivial questions from your own data.

Implementation 🛠️
• Implement a multi-step process involving question anonymization, high-level planning, task breakdown, adaptive information retrieval and question answering, continuous re-planning, and rigorous answer verification to ensure grounded and accurate responses.

Getting Started

To begin exploring and building GenAI agents:

Clone this repository:

`1`	`git clone https://github.com/NirDiamant/GenAI_Agents.git`

Navigate to the technique you’re interested in:
1

cd all_agents_tutorials/technique-name
Follow the detailed implementation guide in each technique’s notebook.

Contributing

We welcome contributions from the community! If you have a new technique or improvement to suggest:

Fork the repository
Create your feature branch: git checkout -b feature/AmazingFeature
Commit your changes: git commit -m 'Add some AmazingFeature'
Push to the branch: git push origin feature/AmazingFeature
Open a pull request

Contributors

License

This project is licensed under a custom non-commercial license - see the LICENSE file for details.

⭐️ If you find this repository helpful, please consider giving it a star!

Keywords: GenAI, Generative AI, Agents, NLP, AI, Machine Learning, Natural Language Processing, LLM, Conversational AI, Task-Oriented AI

LibreChat

Fri, 04 Jul 2025 15:31:25 +0800

danny-avila/LibreChat

LibreChat

✨ Features

🖥️ UI & Experience inspired by ChatGPT with enhanced design and features
🤖 AI Model Selection:
- Anthropic (Claude), AWS Bedrock, OpenAI, Azure OpenAI, Google, Vertex AI, OpenAI Assistants API (incl. Azure)
- Custom Endpoints: Use any OpenAI-compatible API with LibreChat, no proxy required
- Compatible with Local & Remote AI Providers:
  - Ollama, groq, Cohere, Mistral AI, Apple MLX, koboldcpp, together.ai,
  - OpenRouter, Perplexity, ShuttleAI, Deepseek, Qwen, and more
🔧 Code Interpreter API:
- Secure, Sandboxed Execution in Python, Node.js (JS/TS), Go, C/C++, Java, PHP, Rust, and Fortran
- Seamless File Handling: Upload, process, and download files directly
- No Privacy Concerns: Fully isolated and secure execution
🔦 Agents & Tools Integration:
- LibreChat Agents:
  - No-Code Custom Assistants: Build specialized, AI-driven helpers without coding
  - Flexible & Extensible: Attach tools like DALL-E-3, file search, code execution, and more
  - Compatible with Custom Endpoints, OpenAI, Azure, Anthropic, AWS Bedrock, and more
  - Model Context Protocol (MCP) Support for Tools
- Use LibreChat Agents and OpenAI Assistants with Files, Code Interpreter, Tools, and API Actions
🔍 Web Search:
- Search the internet and retrieve relevant information to enhance your AI context
- Combines search providers, content scrapers, and result rerankers for optimal results
- Learn More →
🪄 Generative UI with Code Artifacts:
- Code Artifacts allow creation of React, HTML, and Mermaid diagrams directly in chat
🎨 Image Generation & Editing
- Text-to-image and image-to-image with GPT-Image-1
- Text-to-image with DALL-E (3/2), Stable Diffusion, Flux, or any MCP server
- Produce stunning visuals from prompts or refine existing images with a single instruction
💾 Presets & Context Management:
- Create, Save, & Share Custom Presets
- Switch between AI Endpoints and Presets mid-chat
- Edit, Resubmit, and Continue Messages with Conversation branching
- Fork Messages & Conversations for Advanced Context control
💬 Multimodal & File Interactions:
- Upload and analyze images with Claude 3, GPT-4.5, GPT-4o, o1, Llama-Vision, and Gemini 📸
- Chat with Files using Custom Endpoints, OpenAI, Azure, Anthropic, AWS Bedrock, & Google 🗃️
🌎 Multilingual UI:
- English, 中文, Deutsch, Español, Français, Italiano, Polski, Português Brasileiro
- Русский, 日本語, Svenska, 한국어, Tiếng Việt, 繁體中文, العربية, Türkçe, Nederlands, עברית
🧠 Reasoning UI:
- Dynamic Reasoning UI for Chain-of-Thought/Reasoning AI models like DeepSeek-R1
🎨 Customizable Interface:
- Customizable Dropdown & Interface that adapts to both power users and newcomers
🗣️ Speech & Audio:
- Chat hands-free with Speech-to-Text and Text-to-Speech
- Automatically send and play Audio
- Supports OpenAI, Azure OpenAI, and Elevenlabs
📥 Import & Export Conversations:
- Import Conversations from LibreChat, ChatGPT, Chatbot UI
- Export conversations as screenshots, markdown, text, json
🔍 Search & Discovery:
- Search all messages/conversations
👥 Multi-User & Secure Access:
- Multi-User, Secure Authentication with OAuth2, LDAP, & Email Login Support
- Built-in Moderation, and Token spend tools
⚙️ Configuration & Deployment:
- Configure Proxy, Reverse Proxy, Docker, & many Deployment options
- Use completely local or deploy on the cloud
📖 Open-Source & Community:
- Completely Open-Source & Built in Public
- Community-driven development, support, and feedback

For a thorough review of our features, see our docs here 📚

🪶 All-In-One AI Conversations with LibreChat

LibreChat brings together the future of assistant AIs with the revolutionary technology of OpenAI’s ChatGPT. Celebrating the original styling, LibreChat gives you the ability to integrate multiple AI models. It also integrates and enhances original client features such as conversation and message search, prompt templates and plugins.

With LibreChat, you no longer need to opt for ChatGPT Plus and can instead use free or pay-per-call APIs. We welcome contributions, cloning, and forking to enhance the capabilities of this advanced chatbot platform.

Click on the thumbnail to open the video☝️

🌐 Resources

GitHub Repo:

RAG API: github.com/danny-avila/rag_api
Website: github.com/LibreChat-AI/librechat.ai

Other:

Website: librechat.ai
Documentation: librechat.ai/docs
Blog: librechat.ai/blog

📝 Changelog

Keep up with the latest updates by visiting the releases page and notes:

⚠️ Please consult the changelog for breaking changes before updating.

⭐ Star History

✨ Contributions

Contributions, suggestions, bug reports and fixes are welcome!

For new features, components, or extensions, please open an issue and discuss before sending a PR.

If you’d like to help translate LibreChat into your language, we’d love your contribution! Improving our translations not only makes LibreChat more accessible to users around the world but also enhances the overall user experience. Please check out our Translation Guide.

💖 This project exists in its current state thanks to all the people who contribute

🎉 Special Thanks

We thank Locize for their translation management tools that support multiple languages in LibreChat.

langchain4j

Sun, 08 Jun 2025 15:28:32 +0800

langchain4j/langchain4j

LangChain for Java: Supercharge your Java application with the power of LLMs

Introduction

Welcome!

The goal of LangChain4j is to simplify integrating LLMs into Java applications.

Here’s how:

Unified APIs: LLM providers (like OpenAI or Google Vertex AI) and embedding (vector) stores (such as Pinecone or Milvus) use proprietary APIs. LangChain4j offers a unified API to avoid the need for learning and implementing specific APIs for each of them. To experiment with different LLMs or embedding stores, you can easily switch between them without the need to rewrite your code. LangChain4j currently supports 15+ popular LLM providers and 15+ embedding stores.
Comprehensive Toolbox: Since early 2023, the community has been building numerous LLM-powered applications, identifying common abstractions, patterns, and techniques. LangChain4j has refined these into practical code. Our toolbox includes tools ranging from low-level prompt templating, chat memory management, and function calling to high-level patterns like Agents and RAG. For each abstraction, we provide an interface along with multiple ready-to-use implementations based on common techniques. Whether you’re building a chatbot or developing a RAG with a complete pipeline from data ingestion to retrieval, LangChain4j offers a wide variety of options.
Numerous Examples: These examples showcase how to begin creating various LLM-powered applications, providing inspiration and enabling you to start building quickly.

LangChain4j began development in early 2023 amid the ChatGPT hype. We noticed a lack of Java counterparts to the numerous Python and JavaScript LLM libraries and frameworks, and we had to fix that! Although “LangChain” is in our name, the project is a fusion of ideas and concepts from LangChain, Haystack, LlamaIndex, and the broader community, spiced up with a touch of our own innovation.

We actively monitor community developments, aiming to quickly incorporate new techniques and integrations, ensuring you stay up-to-date. The library is under active development. While some features are still being worked on, the core functionality is in place, allowing you to start building LLM-powered apps now!

Documentation

Documentation can be found here.

The documentation chatbot (experimental) can be found here.

Getting Started

Getting started guide can be found here.

Code Examples

Please see examples of how LangChain4j can be used in langchain4j-examples repo:

Examples in plain Java
Examples with Quarkus (uses quarkus-langchain4j dependency)
Example with Spring Boot
Examples with Helidon (uses io.helidon.integrations.langchain4j dependency)
Examples with Micronaut (uses micronaut-langchain4j dependency)

Useful Materials

Useful materials can be found here.

Get Help

Please use Discord or GitHub discussions to get help.

Request Features

Please let us know what features you need by opening an issue.

Contribute

Contribution guidelines can be found here.

OpenHands

Sun, 25 May 2025 15:25:59 +0800

All-Hands-AI/OpenHands

OpenHands: Code Less, Make More

Welcome to OpenHands (formerly OpenDevin), a platform for software development agents powered by AI.

OpenHands agents can do anything a human developer can: modify code, run commands, browse the web, call APIs, and yes—even copy code snippets from StackOverflow.

Learn more at docs.all-hands.dev, or sign up for OpenHands Cloud to get started.

[!IMPORTANT] Using OpenHands for work? We’d love to chat! Fill out this short form to join our Design Partner program, where you’ll get early access to commercial features and the opportunity to provide input on our product roadmap.

☁️ OpenHands Cloud

The easiest way to get started with OpenHands is on OpenHands Cloud, which comes with $50 in free credits for new users.

💻 Running OpenHands Locally

OpenHands can also run on your local system using Docker. See the Running OpenHands guide for system requirements and more information.

[!WARNING] On a public network? See our Hardened Docker Installation Guide to secure your deployment by restricting network binding and implementing additional security measures.

docker pull docker.all-hands.dev/all-hands-ai/runtime:0.39-nikolaik

docker run -it --rm --pull=always \
    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.39-nikolaik \
    -e LOG_ALL_EVENTS=true \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v ~/.openhands-state:/.openhands-state \
    -p 3000:3000 \
    --add-host host.docker.internal:host-gateway \
    --name openhands-app \
    docker.all-hands.dev/all-hands-ai/openhands:0.39

You’ll find OpenHands running at http://localhost:3000!

When you open the application, you’ll be asked to choose an LLM provider and add an API key. Anthropic’s Claude Sonnet 4 (anthropic/claude-sonnet-4-20250514) works best, but you have many options.

💡 Other ways to run OpenHands

[!CAUTION] OpenHands is meant to be run by a single user on their local workstation. It is not appropriate for multi-tenant deployments where multiple users share the same instance. There is no built-in authentication, isolation, or scalability.

If you’re interested in running OpenHands in a multi-tenant environment, please get in touch with us for advanced deployment options.

You can also connect OpenHands to your local filesystem, run OpenHands in a scriptable headless mode, interact with it via a friendly CLI, or run it on tagged issues with a github action.

Visit Running OpenHands for more information and setup instructions.

If you want to modify the OpenHands source code, check out Development.md.

Having issues? The Troubleshooting Guide can help.

📖 Documentation

To learn more about the project, and for tips on using OpenHands, check out our documentation.

There you’ll find resources on how to use different LLM providers, troubleshooting resources, and advanced configuration options.

🤝 How to Join the Community

OpenHands is a community-driven project, and we welcome contributions from everyone. We do most of our communication through Slack, so this is the best place to start, but we also are happy to have you contact us on Discord or Github:

Join our Slack workspace - Here we talk about research, architecture, and future development.
Join our Discord server - This is a community-run server for general discussion, questions, and feedback.
Read or post Github Issues - Check out the issues we’re working on, or add your own ideas.

See more about the community in COMMUNITY.md or find details on contributing in CONTRIBUTING.md.

📈 Progress

See the monthly OpenHands roadmap here (updated at the maintainer’s meeting at the end of each month).

📜 License

Distributed under the MIT License. See LICENSE for more information.

🙏 Acknowledgements

OpenHands is built by a large number of contributors, and every contribution is greatly appreciated! We also build upon other open source projects, and we are deeply thankful for their work.

For a list of open source projects and licenses used in OpenHands, please see our CREDITS.md file.

📚 Cite

@misc{openhands,
      title={{OpenHands: An Open Platform for AI Software Developers as Generalist Agents}},
      author={Xingyao Wang and Boxuan Li and Yufan Song and Frank F. Xu and Xiangru Tang and Mingchen Zhuge and Jiayi Pan and Yueqi Song and Bowen Li and Jaskirat Singh and Hoang H. Tran and Fuqiang Li and Ren Ma and Mingzhang Zheng and Bill Qian and Yanjun Shao and Niklas Muennighoff and Yizhe Zhang and Binyuan Hui and Junyang Lin and Robert Brennan and Hao Peng and Heng Ji and Graham Neubig},
      year={2024},
      eprint={2407.16741},
      archivePrefix={arXiv},
      primaryClass={cs.SE},
      url={https://arxiv.org/abs/2407.16741},
}

potpie

Sat, 19 Apr 2025 15:26:05 +0800

potpie-ai/potpie

App | Documentation | API Reference | Chat with 🥧 Repo

Prompt-To-Agent: Create custom engineering agents for your code

Potpie is an open-source platform that creates AI agents specialized in your codebase, enabling automated code analysis, testing, and development tasks. By building a comprehensive knowledge graph of your code, Potpie’s agents can understand complex relationships and assist with everything from debugging to feature development.

📚 Table of Contents

🥧 Why Potpie?

🧠 Deep Code Understanding: Built-in knowledge graph captures relationships between code components
🤖 Pre-built & Custom Agents: Ready-to-use agents for common tasks + build your own
🔄 Seamless Integration: Works with your existing development workflow
📈 Flexible: Handles codebases of any size or language

🔌 VSCode Extension

Bring the power of Potpie’s AI agents directly into your development environment with our VSCode extension:

Direct Integration: Access all Potpie agents without leaving your editor
Quick Setup: Install directly from the VSCode Marketplace
Seamless Workflow: Ask questions, get explanations, and implement suggestions right where you code

🤖 Potpie’s Prebuilt Agents

Potpie offers a suite of specialized codebase agents for automating and optimizing key aspects of software development:

Debugging Agent: Automatically analyzes stacktraces and provides debugging steps specific to your codebase.
Codebase Q&A Agent: Answers questions about your codebase and explains functions, features, and architecture.
Code Changes Agent: Analyzes code changes, identifies affected APIs, and suggests improvements before merging.
Integration Test Agent: Generates integration test plans and code for flows to ensure components work together properly.
Unit Test Agent: Automatically creates unit test plan and code for individual functions to enhance test coverage.
LLD Agent: Creates a low level design for implementing a new feature by providing functional requirements to this agent.
Code Generation Agent: Generates code for new features, refactors existing code, and suggests optimizations.

🛠️ Potpie’s Tooling System

Potpie provides a set of tools that agents can use to interact with the knowledge graph and the underlying infrastructure:

get_code_from_probable_node_name: Retrieves code snippets based on a probable node name.
get_code_from_node_id: Fetches code associated with a specific node ID.
get_code_from_multiple_node_ids: Retrieves code snippets for multiple node IDs simultaneously.
ask_knowledge_graph_queries: Executes vector similarity searches to obtain relevant information.
get_nodes_from_tags: Retrieves nodes tagged with specific keywords.
get_code_graph_from_node_id/name: Fetches code graph structures for a specific node.
change_detection: Detects changes in the current branch compared to the default branch.
get_code_file_structure: Retrieves the file structure of the codebase.

🚀 Getting Started

Prerequisites

Docker installed and running
Git installed (for repository access)
Python 3.10.x

Potpie UI

An easy to use interface to interact with your Agents

Initialize the UI Submodule

To initialize the submodule:

`1`	`git submodule update --init`

1. Navigate to the `potpie-ui` Directory

`1`	`cd potpie-ui`

2. Update the Main Branch and Checkout

1
2

git checkout main
git pull origin main

3. Set Up the Environment

Create a .env file in the potpie-ui directory and copy the required configuration from .env.template.

`1`	`cp .env.template .env`

4. Build the Frontend

`1`	`pnpm build`

5. Start the Application

`1`	`pnpm start`

Setup Steps

Install Python 3.10

Download and install Python 3.10 from the official Python website: https://www.python.org/downloads/release/python-3100/

Prepare Your Environment

Create a .env file based on the .env.template

Add the following required configurations:

isDevelopmentMode=enabled
ENV=development
POSTGRES_SERVER=postgresql://postgres:mysecretpassword@localhost:5432/momentum
NEO4J_URI=bolt://127.0.0.1:7687
NEO4J_USERNAME=neo4j
NEO4J_PASSWORD=mysecretpassword
REDISHOST=127.0.0.1
REDISPORT=6379
BROKER_URL=redis://127.0.0.1:6379/0
CELERY_QUEUE_NAME=dev
defaultUsername=defaultuser
PROJECT_PATH=projects #repositories will be downloaded/cloned to this path on your system.
{PROVIDER}_API_KEY=sk-proj-your-key #your provider key e.g. ANTHROPIC_API_KEY for Anthropic
INFERENCE_MODEL=ollama_chat/qwen2.5-coder:7b #provider model name
CHAT_MODEL=ollama_chat/qwen2.5-coder:7b #provider model name

INFERENCE_MODEL and CHAT_MODEL correspond to the models that will be used for generating knowledge graph and for agent reasoning respectively. These model names should be in the format of provider/model_name format or as expected by Litellm. For more information, refer to the Litellm documentation.

Create a Virtual Environment using Python 3.10:

1
2

python3.10 -m venv venv
source venv/bin/activate

Install dependencies in your venv:
1

pip install -r requirements.txt

Start Potpie

1
2

chmod +x start.sh
./start.sh

Windows

`1`	`./start.ps1`

Authentication Setup (Skip this step in development mode)

curl -X POST 'http://localhost:8001/api/v1/login' \
  -H 'Content-Type: application/json' \
  -d '{
    "email": "your-email",
    "password": "your-password"
  }'
# Save the bearer token from the response for subsequent requests

Initialize Repository Parsing

# For development mode:
curl -X POST 'http://localhost:8001/api/v1/parse' \
  -H 'Content-Type: application/json' \
  -d '{
    "repo_path": "path/to/local/repo",
    "branch_name": "main"
  }'

# For production mode:
curl -X POST 'http://localhost:8001/api/v1/parse' \
  -H 'Content-Type: application/json' \
  -d '{
    "repo_name": "owner/repo-name",
    "branch_name": "main"
  }'
# Save the project_id from the response

Monitor Parsing Status

1
2

curl -X GET 'http://localhost:8001/api/v1/parsing-status/your-project-id'
# Wait until parsing is complete

View Available Agents

1
2

curl -X GET 'http://localhost:8001/api/v1/list-available-agents/?list_system_agents=true'
# Note down the agent_id you want to use

Create a Conversation

curl -X POST 'http://localhost:8001/api/v1/conversations/' \
  -H 'Content-Type: application/json' \
  -d '{
    "user_id": "your_user_id",
    "title": "My First Conversation",
    "status": "active",
    "project_ids": ["your-project-id"],
    "agent_ids": ["chosen-agent-id"]
  }'
# Save the conversation_id from the response

Start Interacting with Your Agent

curl -X POST 'http://localhost:8001/api/v1/conversations/your-conversation-id/message/' \
  -H 'Content-Type: application/json' \
  -d '{
    "content": "Your question or request here",
    "node_ids":[]
  }'

View Conversation History (Optional)

`1`	`curl -X GET 'http://localhost:8001/api/v1/conversations/your-conversation-id/messages/?start=0&limit=10'`

💡 Use Cases

Onboarding: For developers new to a codebase, the codebase QnA agent helps them understand the codebase and get up to speed quickly. Ask it how to setup a new project, how to run the tests etc

We tried to onboard ourselves with Potpie to the AgentOps codebase and it worked like a charm : Video here.

Codebase Understanding: Answer questions about any library you’re integrating, explain functions, features, and architecture.

We used the Q&A agent to understand the underlying working of a feature of the CrewAI codebase that was not documented in official docs : Video here.

Low Level Design: Get detailed implementation plans for new features or improvements before writing code.

We fed an open issue from the Portkey-AI/Gateway project to this agent to generate a low level design for it: Video here.

Reviewing Code Changes: Understand the functional impact of changes and compute the blast radius of modifications.
Debugging: Get step-by-step debugging guidance based on stacktraces and codebase context.
Testing: Generate contextually aware unit and integration test plans and test code that understand your codebase’s structure and purpose.

🛠️ Custom Agents Upgrade ✨

With Custom Agents, you can design personalized tools that handle repeatable tasks with precision. Key components include:

System Instructions: Define the agent’s task, goal, and expected output
Agent Information: Metadata about the agent’s role and context
Tasks: Individual steps for job completion
Tools: Functions for querying the knowledge graph or retrieving code

🗝️ Accessing Agents via API Key

You can access Potpie Agents through an API key, enabling integration into CI/CD workflows and other automated processes. For detailed instructions, please refer to the Potpie API documentation.

Generate an API Key: Easily create an API key for secure access.
Parse Repositories: Use the Parse API to analyze code repositories and obtain a project ID.
Monitor Parsing Status: Check the status of your parsing requests.
Create Conversations: Initiate conversations with specific agents using project and agent IDs adn get a conversation id.
Send Messages: Communicate with agents by sending messages within a conversation.

🎨 Make Potpie Your Own

Potpie is designed to be flexible and customizable. Here are key areas to personalize your own deployment:

Effortless Agent Creation:

Design custom agents tailored to your specific tasks using a single prompt. Utilize the following API to create your custom agents:

curl -X POST "http://localhost:8001/api/v1/custom-agents/agents/auto" \
     -H "Content-Type: application/json" \
     -d '{
           "prompt": "Aan agent that takes stacktrace as input and gives root cause analysis and proposed solution as output"
         }'

Read more about other custom agent APIs to edit and delete your custom agents in our documentation.

Tool Integration

Edit or add tools in the app/modules/intelligence/tools directory for your custom agents. Initialise the tools in the app/modules/intelligence/tools/tool_service.py file and include them in your agent.

🤝 Contributing

We welcome contributions! To contribute:

Fork the repository
Create a new branch (git checkout -b feature-branch)
Make your changes
Commit (git commit -m 'Add new feature')
Push to the branch (git push origin feature-branch)
Open a Pull Request

See Contributing Guide for more details.

📜 License

This project is licensed under the Apache 2.0 License - see the LICENSE file for details.

💪 Thanks To All Contributors

Thanks for spending your time helping build Potpie. Keep rocking 🥂

Agents on Producthunt daily

cai

aliasrobotics/cai

Cybersecurity AI (CAI)

:bookmark: Table of Contents

🎯 Impact

🏆 Competitions and challenges

📊 Research Impact

📚 Research products: Cybersecurity AI

PoCs

Motivation

:bust_in_silhouette: Why CAI?

Ethical principles behind CAI

Closed-source alternatives

Learn - CAI Fluency

:nut_and_bolt: Install

OS X

Ubuntu 24.04

Ubuntu 20.04

Windows WSL

Android

:nut_and_bolt: Setup .env file

🔹 Custom OpenAI Base URL Support

:triangular_ruler: Architecture:

🔹 Agent

🔹 Tools

🔹 Handoffs

🔹 Patterns

🔹 Turns and Interactions

🔹 Tracing

🔹 Guardrails

🔹 Human-In-The-Loop (HITL)

:rocket: Quickstart

Environment Variables

OpenRouter Integration

Azure OpenAI

MCP

Development

Contributions

Optional Requirements: caiextensions

:information_source: Usage Data Collection

Reproduce CI-Setup locally

FAQ

Citation

Acknowledgements

Academic Collaborations

crewAI

crewAIInc/crewAI

Fast and Flexible Multi-Agent Automation Framework

CrewAI Enterprise Suite

Crew Control Plane Key Features:

Table of contents

Why CrewAI?

Getting Started

Understanding Flows and Crews

Getting Started with Installation

1. Installation

Troubleshooting Dependencies

Common Issues

2. Setting Up Your Crew with the YAML Configuration

To customize your project, you can:

Example of a simple crew with a sequential process:

3. Running Your Crew

Key Features

Examples

Quick Tutorial

Write Job Descriptions

Trip Planner

Stock Analysis

Using Crews and Flows Together

Connecting Your Crew to a Model

How CrewAI Compares

Contribution

Installing Dependencies

Virtual Env

Pre-commit hooks

Running Tests

Running static type checks

Packaging

Installing Locally

Cybersecurity AI (`CAI`)

📚 Research products: `Cybersecurity AI`

Learn - `CAI` Fluency

:nut_and_bolt: Setup `.env` file