Rootflo is an alternative to Langgraph, and CrewAI. It lets you easily build composable agentic workflows from using simple components to any size, unlocking the full potential of LLMs.
Checkout the docs »
Github
•
Website
•
Roadmap
Build production-ready AI agents and teams with minimal code
Flo AI is a Python framework that makes building production-ready AI agents and teams as easy as writing YAML. Think "Kubernetes for AI Agents" - compose complex AI architectures using pre-built components while maintaining the flexibility to create your own.
- 🔌 Truly Composable: Build complex AI systems by combining smaller, reusable components
- 🏗️ Production-Ready: Built-in best practices and optimizations for production deployments
- 📝 YAML-First: Define your entire agent architecture in simple YAML
- 🔧 Flexible: Use pre-built components or create your own
- 🤝 Team-Oriented: Create and manage teams of AI agents working together
- 📚 RAG Support: Built-in support for Retrieval-Augmented Generation
- 🔄 Langchain Compatible: Works with all your favorite Langchain tools
FloAI follows an agent team architecture, where agents are the basic building blocks, and teams can have multiple agents and teams themselves can be part of bigger teams.
Building a working agent or team involves 3 steps:
- Create a session using
FloSession, and register your tools and models - Define you agent/team/team of teams using yaml or code
- Build and run using
Flo
pip install flo-ai
# or using poetry
poetry add flo-aifrom flo_ai import Flo, FloSession
from langchain_openai import ChatOpenAI
from langchain_community.tools.tavily_search.tool import TavilySearchResults
# init your LLM
llm = ChatOpenAI(temperature=0)
# create a session and register your tools
session = FloSession(llm).register_tool(name="TavilySearchResults", tool=TavilySearchResults())
# define your agent yaml
simple_weather_checking_agent = """
apiVersion: flo/alpha-v1
kind: FloAgent
name: weather-assistant
agent:
name: WeatherAssistant
job: >
Given the city name you are capable of answering the latest whether this time of the year by searching the internet
tools:
- name: InternetSearchTool
"""
flo = Flo.build(session, yaml=simple_weather_checking_agent)
# Start streaming results
for response in flo.stream("Write about recent AI developments"):
print(response)from flo_ai import FloAgent
session = FloSession(llm)
weather_agent = FloAgent.create(
session=session,
name="WeatherAssistant",
job="Given the city name you are capable of answering the latest whether this time of the year by searching the internet",
tools=[TavilySearchResults()]
)
agent_flo: Flo = Flo.create(session, weather_agent)
result = agent_flo.invoke("Whats the whether in New Delhi, India ?")from flo_ai import Flo, FloSession
from langchain_openai import ChatOpenAI
from langchain_community.tools.tavily_search.tool import TavilySearchResults
# Define your team in YAML
yaml_config = """
apiVersion: flo/alpha-v1
kind: FloRoutedTeam
name: research-team
team:
name: ResearchTeam
router:
name: TeamLead
kind: supervisor
agents:
- name: Researcher
role: Research Specialist
job: Research latest information on given topics
tools:
- name: TavilySearchResults
- name: Writer
role: Content Creator
job: Create engaging content from research
"""
# Set up and run
llm = ChatOpenAI(temperature=0)
session = FloSession(llm).register_tool(name="TavilySearchResults", tool=TavilySearchResults())
flo = Flo.build(session, yaml=yaml_config)
# Start streaming results
for response in flo.stream("Write about recent AI developments"):
print(response)Note: You can make each of the above agents including the router to use different models, giving flexibility to combine the power of different LLMs. To know more, check multi-model integration in detailed documentation
from flo_ai import FloSupervisor, FloAgent, FloSession, FloTeam, FloLinear
from langchain_openai import ChatOpenAI
from langchain_community.tools.tavily_search.tool import TavilySearchResults
llm = ChatOpenAI(temperature=0, model_name='gpt-4o')
session = FloSession(llm).register_tool(
name="TavilySearchResults",
tool=TavilySearchResults()
)
researcher = FloAgent.create(
session,
name="Researcher",
role="Internet Researcher", # optional
job="Do a research on the internet and find articles of relevent to the topic asked by the user",
tools=[TavilySearchResults()]
)
blogger = FloAgent.create(
session,
name="BlogWriter",
role="Thought Leader", # optional
job="Able to write a blog using information provided",
tools=[TavilySearchResults()]
)
marketing_team = FloTeam.create(session, "Marketing", [researcher, blogger])
head_of_marketing = FloSupervisor.create(session, "Head-of-Marketing", marketing_team)
marketing_flo = Flo.create(session, routed_team=head_of_marketing)FloAI supports all the tools built and available in langchain_community package. To know more these tools, go here.
Along with that FloAI has a decorator @flotool which makes any function into a tool.
Creating a simple tool using @flotool:
from flo_ai.tools import flotool
from pydantic import BaseModel, Field
# define argument schema
class AdditionToolInput(BaseModel):
numbers: List[int] = Field(..., description='List of numbers to add')
@flotool(name='AdditionTool', description='Tool to add numbers')
async def addition_tool(numbers: List[int]) -> str:
result = sum(numbers)
await asyncio.sleep(1)
return f'The sum is {result}'
# async tools can also be defined
# when using async tool, while running the flo use async invoke
@flotool(
name='MultiplicationTool',
description='Tool to multiply numbers to get product of numbers',
)
async def mul_tool(numbers: List[int]) -> str:
result = sum(numbers)
await asyncio.sleep(1)
return f'The product is {result}'
# register your tool or use directly in code impl
session.register_tool(name='Adder', tool=addition_tool)Note: @flotool comes with inherent error handling capabilities to retry if an exception is thrown. Use unsafe=True to disable error handling
Visit our comprehensive documentation for:
- Detailed tutorials
- Architecture deep-dives
- API reference
- Logging
- Error handling
- Observers
- Dynamic model switching
- Best practices
- Advanced examples
- Faster Development: Build complex AI systems in minutes, not days
- Production Focus: Built-in optimizations and best practices
- Flexibility: Use our components or build your own
- Maintainable: YAML-first approach makes systems easy to understand and modify
- Scalable: From single agents to complex team hierarchies
- Testable: Each component can be tested independently
- 🤖 Customer Service Automation
- 📊 Data Analysis Pipelines
- 📝 Content Generation
- 🔍 Research Automation
- 🎯 Task-Specific AI Teams
We love your input! Check out our Contributing Guide to get started. Ways to contribute:
- 🐛 Report bugs
- 💡 Propose new features
- 📝 Improve documentation
- 🔧 Submit PRs
Flo AI is MIT Licensed.
Built with ❤️ using:
Flo: 🔥🔥🔥 Simple way to create composable AI agents
Unlock the Power of Customizable AI Workflows with FloAI’s Intuitive and Flexible Agentic Framework
Build an Agentic AI customer support bot using FloAI
We built an open-source agentic AI workflow builder named FloAI and used it to create an agentic customer support agent.
Build an Agentic RAG using FloAI in minutes
FloAI has just made implementing agentic RAG simple and easy to manage