Inteligência Artificial Colaborativa: Criando Sistemas Multiagentes com Python, LLMs e CrewAI

Introdução

Na era da Inteligência Artificial generativa, estamos acostumados a interagir com modelos poderosos como o ChatGPT. Mas, e se em vez de depender de um único agente superinteligente, pudéssemos distribuir responsabilidades entre vários agentes especializados, cada um com seu foco e expertise? Essa é a proposta da arquitetura multiagente com Python e IA.

Neste artigo, vamos mostrar como combinar Python, CrewAI, LangChain, LLMs como OpenAI GPT e Groq LLaMA, para criar sistemas inteligentes colaborativos. Veremos também aplicações práticas, com destaque para o projeto Trip Planner Crew, uma solução que exemplifica o poder dessa abordagem, ao utilizar agentes autônomos para tarefas como recomendação de cidades, planejamento de roteiros e sugestões locais baseadas em clima e eventos.

O Que é uma Arquitetura Multiagente?

Uma arquitetura multiagente é composta por diversas entidades inteligentes chamadas agentes, que colaboram para atingir um objetivo comum. Cada agente tem uma função bem definida e pode utilizar ferramentas, consultar modelos de linguagem e tomar decisões autônomas. Esses agentes se comunicam e compartilham informações para compor soluções complexas.

Por exemplo, em um sistema de planejamento de viagens, podemos ter:

• Um agente responsável por identificar a melhor cidade com base em clima, custo e preferências.
• Um agente especialista em montar roteiros dia a dia.
• Um guia local virtual para sugerir atrações escondidas e dicas culturais.

Essa colaboração é orquestrada usando CrewAI, uma biblioteca Python que permite definir agentes, tarefas e controladores. Os agentes são alimentados por LLMs como GPT e LLaMA, acessados via LangChain, que fornece uma camada de abstração poderosa para integração com ferramentas, contexto e memória.

Vamos examinar, na prática, como isso é feito com Python:

Definindo Agentes com CrewAI

from crewai import Agent
from langchain_openai import ChatOpenAI

agent = Agent(
 role="Especialista em Destinos",
 backstory="Expert em recomendações baseadas em interesses e sazonalidade",
 goal="Identificar a melhor cidade para o viajante com base em dados atualizados",
 tools=[SerperDevTool(), WebsiteSearchTool()],
 verbose=True,
 llm=ChatOpenAI(model="gpt-3.5-turbo")
)

Neste exemplo:

• role define o papel do agente.
• goal define sua missão.
• tools são recursos externos que o agente pode usar (busca, scraping, etc).
• llm é o modelo de linguagem que executará as inferências.

Definindo Tarefas com CrewAI

from crewai import Task

task = Task(
 description="Selecionar a melhor cidade com base nas preferências do usuário",
 agent=agent,
 expected_output="Cidade recomendada com justificativas sobre clima, custo e atrações",
)

Tarefas são unidades de trabalho atribuídas a agentes. Elas contêm instruções específicas e definem o resultado esperado.

Como CrewAI e LangChain Trabalham Juntos

CrewAI gerencia a orquestração de múltiplos agentes e tarefas. Já o LangChain atua nos bastidores:

• Formatando prompts complexos.
• Gerenciando a memória conversacional do agente.
• Chamando ferramentas adicionais (APIs, busca, web scraping).

Isso significa que você pode criar agentes inteligentes com "superpoderes": eles conversam com modelos LLMs, buscam informações em tempo real e executam raciocínio contextual.

Exemplo Real Integrado

controller = TripController()
result = controller.run_trip_plan(
 origin="São Paulo",
 cities=["Paris", "Lisboa", "Barcelona"],
 date_range="2025-06-10 to 2025-06-17",
 interests="arte, gastronomia"
)

Neste trecho, o controlador coordena a execução de tarefas com os seguintes agentes:

• City Selection Expert: compara cidades.
• Expert Travel Agent: monta o itinerário.
• Local Tour Guide: coleta informações culturais e logísticas.

O resultado final é uma estrutura JSON com sumários, planos diários, recomendações personalizadas e previsões.

Coordenação e Execução com CrewAI

O coração da execução multiagente está na classe Crew, que recebe a lista de agentes e tarefas. Ao chamar kickoff(), cada agente realiza sua tarefa e retorna sua saída, que pode ser utilizada por outros agentes ou pelo sistema.

from crewai import Crew

crew = Crew(
 agents=[expert_travel_agent, city_selection_expert, local_tour_guide],
 tasks=[plan_itinerary, identify_city, gather_city_info],
 verbose=True,
)

result = crew.kickoff()

A saída (result) contém:

• Sumário final com recomendações cruzadas.
• Resultados individuais por tarefa.
• Uso de tokens e logs úteis para auditoria.

Resultado Estruturado

structured_result = {
 "final_summary": result.raw,
 "task_outputs": [
{
 "description": task.description,
 "expected_output": task.expected_output,
 "summary": task.summary,
 "raw": task.raw,
 "agent": task.agent.role
}
for task in result.tasks_output
 ],
 "token_usage": result.metrics,
}

Esse formato facilita o uso do sistema em interfaces como Streamlit, Dash ou integrações com APIs externas.

Interface com o Usuário: Streamlit em Ação

Uma das grandes vantagens de usar Python é poder transformar rapidamente um backend complexo em uma interface amigável. Utilizando Streamlit, podemos disponibilizar o sistema para qualquer pessoa de forma visual e interativa:

import streamlit as st

def run_ui(controller):
st.title("✈️ Your Trip Details")

with st.sidebar:
  st.header("✈️ Details of your trip")
  origin = st.text_input("Origin")
  cities = st.text_input("Cities to consider")
  date_range = st.text_input("Travel period (e.g. 2025-06-10 to 2025-06-17)")
  interests = st.text_input("Interests (e.g. culture, food, nature)")

if st.button("Generate Itinerary"):
  if not all([origin, cities, date_range, interests]):
    st.error("❌ Please fill out all fields.")
  else:
    with st.spinner("⏳ Generating your itinerary..."):
      result = controller.run_trip_plan(origin, cities, date_range, interests)

    if "final_summary" in result and result["final_summary"]:
      st.subheader("✅ Final Summary from the AI")
      st.markdown(result["final_summary"])

    if "task_outputs" in result and result["task_outputs"]:
      st.subheader("📋 Completed Tasks")
      for i, task in enumerate(result["task_outputs"]):
        with st.expander(f"{i+1}. {task.get('agent', 'Agente')}"):
          st.markdown(f"**Task Description:** {task['description']}")
          st.markdown(f"**Result:**\n\n{task['raw']}")

    if "token_usage" in result and result["token_usage"]:
      st.subheader("📊 Token Usage")
      st.json(result["token_usage"])

Arquitetura Multiagente: Diagrama de Funcionamento

Esse diagrama ajuda a visualizar o fluxo de trabalho: entrada do usuário → delegação de tarefas → colaboração entre agentes → composição da resposta final.

Conclusão e Próximos Passos

Sistemas multiagentes com Python, LLMs e CrewAI representam uma nova geração de soluções inteligentes. Ao dividir responsabilidades entre agentes especializados, é possível resolver problemas complexos com mais clareza, modularidade e precisão.

Se você trabalha com projetos que envolvem múltiplos critérios, decisões baseadas em contexto ou recomendações, essa arquitetura pode elevar a capacidade do seu sistema. E o melhor: com Python, tudo isso se torna acessível.

Dicas para Expandir:

• Adapte para saúde: agentes especialistas em sintomas, histórico médico, tratamentos.
• Use na educação: agentes que montam planos de estudo, explicam conteúdo e avaliam.
• Aplique em negócios: agentes financeiros, de mercado, de compliance.

Referências

• CrewAI GitHub
• LangChain Documentation
• Streamlit
• OpenAI API
• Groq LLaMA 3
• Serper.dev
• Trip Planner Crew