Say goodbye to manual prompt engineering. AdalFlow is the all-in-one, auto-differentiative solution for optimizing prompts, whether you're using zero-shot or few-shot learning. Backed by our state-of-the-art research (LLM-AutoDiff and Learn-to-Reason), our framework achieves the highest accuracy among all automatic prompt optimization libraries.
The rise of large language models has completely changed the way we build applications—whether it's chatbots, RAG systems, or fully autonomous agents. But as an AI engineer, trying to bring these models into production often feels like stitching together a bunch of experiments, rather than building a stable and reliable system.
We introduce AdalFlow: a PyTorch-like library designed to bring structure, clarity, and optimization to the world of LLM application development. Built as a community-driven project, AdalFlow is uniting AI research and production engineering into a single ecosystem.
The Problem
Modern AI development faces a paradox. On one hand, researchers push the boundaries of model capabilities with new techniques in prompting, evaluation, and optimization. On the other hand, production teams need reproducibility, scalability, and a way to iterate safely on real-world data.
Most libraries excel at one side of the equation but leave the other underserved. AdalFlow was born to bridge this gap. With 100% control and clarity of source code, it empowers researchers to experiment freely while giving product engineers the tools to build and ship with confidence.
What AdalFlow Provides
By treating prompts as first-class citizens and introducing LLM-AutoDiff, AdalFlow provides what's been missing in the LLM ecosystem:
- For researchers: A familiar PyTorch-like environment to prototype new prompting and training methods.
- For engineers: Production-ready workflows that are debuggable, reproducible, and optimizable.
- For teams: A shared framework that unites research and production into one healthy ecosystem.
Prompts as Programming Primitives
If PyTorch turned tensors into the lingua franca of deep learning, AdalFlow treats prompts as the new programming primitives.
Every LLM application boils down to structured prompts and their transformations. AdalFlow embraces this reality by making prompt engineering explicit and optimizable. Behind the scenes, it uses the Jinja2 templating engine to let developers define composable prompt structures, ensuring that LLM apps are both modular and debuggable.
The Component Abstraction
At the heart of AdalFlow lies the Component abstraction. Just as nn.Module became the foundation for PyTorch models, Components unify every stage of an LLM pipeline.
- Component: The base class for all workflows. Handles both training (forward) and inference (call) modes.
- GradComponent: Components capable of backpropagation (e.g., Generators, Retrievers).
- DataComponent: Lightweight components for formatting and parsing data.
- LossComponent: Wraps evaluation metrics and enables gradient-like feedback for text optimization.
Agent Architecture
AdalFlow embraces the ReAct paradigm—combining reasoning (plan) with acting (tool use)—to build autonomous, auditable AI systems. An agent reasons about the task, selects tools, executes them, observes results, and iterates until it can deliver a final answer.
- Agent (planner + tool manager): Handles planning and decision-making via a Generator-based planner.
- Runner (executor + conversation loop): Orchestrates multi-step execution, tool calling, observation handling, timeouts, and final answer synthesis.
This separation lets you swap or customize planning vs. execution independently.
Get Started
We hope this hands-on example enables a fast start. For more information, the Documentation is available.
For more open-source code, follow the Github and give a ⭐. We'd love your feedback!