Creación de agentes de IA autónomos localmente: Una guía paso a paso.
Agentes de IA autónomos que funcionan localmente en una máquina con 16 GB de RAM: comparando modelos de Ollama y frameworks como CrewAI cara a cara, y luego desarrollándolos paso a paso.
Fuentes: Building Autonomous AI Agents Locally: A Step-by-Step Guide for 16GB RAM Systems
Las notas siguientes reconstruyen un camino práctico basado en “Construir agentes de IA autónomos localmente: Una guía paso a paso para sistemas con 16 GB de RAM”. Se da énfasis en los contratos, las verificaciones y los marcadores de posición para código, en lugar de en un enfoque motivacional.
La promesa y el dolor
Al trabajar en la etapa de “La promesa y el dolor”, anote primero el contrato: las entradas requeridas, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones de código. Guarde la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos secretos y las banderas de funcionalidad deben encontrarse en un lugar donde los operadores puedan auditarlos sin tener que leer todo el sistema. Haga un punto de control después de los pasos costosos. La reanudación no debe volver a facturar la misma llamada al LLM cuando un operador intente nuevamente un nodo posterior.
Parte 1: Elegir su arma — El dilema de la selección del modelo — Evaluación de modelos locales para la generación de tokens y la eficiencia agente
Al trabajar en la etapa de Elección de su arma de la Parte 1, anote primero el contrato: entradas requeridas, señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Documente tanto el camino óptimo como el de recuperación. Los intentos repetidos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no de mejoras posteriores. Almacene en caché las instrucciones estables del sistema y los esquemas de herramientas. Reenviar un preámbulo idéntico es una causa común de desperdicio.
Los competidores: Una comparación cara a cara
Al trabajar en la fase The Contenders A Head-to-Head, anote primero el contrato: los datos requeridos, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Prefiera unidades pequeñas y probables sobre scripts extensos. Cuando un paso falla, el fallo debe apuntar a una única responsabilidad y no a un proceso complicado. Haga puntos de control después de los pasos costosos. El sistema de reanudación no debe volver a facturar la misma llamada al LLM cuando un operador intenta nuevamente un nodo posterior.
Qwen3.5:4b — El demonio de la velocidad
Al trabajar en la etapa Qwen3 5 4b, anote primero el contrato: las entradas requeridas, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Trate esta etapa como un contrato entre las entradas y las salidas validadas. Asigne nombres a los artefactos, defina comprobaciones de éxito y rechace las completaciones parciales silenciosas. Haga un punto de control después de los pasos costosos. La función de reanudación no debe volver a facturar la misma llamada al LLM cuando un operador intenta nuevamente un nodo posterior.
Llama3.1:latest (8B) — El generalista fiable
Al trabajar con la versión más reciente de Llama3 1 de 8B, anote primero el contrato: entradas requeridas, señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Registre los tiempos y el costo en tokens o consultas junto con los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando se pasa de entornos de demostración a entornos compartidos. Haga un punto de control después de los pasos costosos. La reanudación no debe volver a facturar la misma llamada al LLM cuando un operador intenta nuevamente un nodo posterior. Al trabajar con la versión más reciente de Llama3 1 de 8B, anote primero el contrato: entradas requeridas, señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Documente tanto el camino óptimo como el camino de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras posteriores.
Gemma4:12b-it-q4_K_M — La potencia para el razonamiento
La etapa de razonamiento de Gemma4 12b-it-q4KM funciona mejor cuando se trata como una superficie medible. Capture una transcripción exitosa, un caso de fallo y la nota de reversión antes de ampliar el alcance. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando un paso falla, el fallo debe apuntar a una sola responsabilidad y no a un proceso complicado. Asigne un presupuesto de tokens por turno y por sesión; las herramientas agenciales amplían el contexto de forma excesiva; los límites estrictos evitan que las demostraciones se conviertan en facturas inesperadas.
Qwen3.5:9b-q4_K_M — La opción ideal
El Qwen3 5 9b-q4KM funciona mejor cuando se trata como una superficie medible. Capture un registro exitoso, un caso de fallo y la nota de reversión antes de ampliar el alcance. Considere esta etapa como un contrato entre las entradas y las salidas validadas. Asigne nombres a los artefactos, defina verificaciones de éxito y rechace las completaciones parciales silenciosas. Mantenga el estado del grafo plano y tipado; los bloques anidados ocultan qué nodo escribió qué campo y provocan interrupciones en la continuación del proceso.
Análisis de modelos comparativos
La etapa de Análisis del Modelo Comparativo funciona mejor cuando se trata como una superficie medible. Capture un transcripte ejemplar, un caso de fallo y la nota de reversión antes de ampliar el alcance. Registre los tiempos y el costo por token o consulta junto con los resultados funcionales. Tener visibilidad del costo desde temprano evita facturas inesperadas cuando el proceso pasa de la demostración a entornos compartidos. Asigne un presupuesto de tokens por turno y por sesión. Las herramientas agenciales amplían el contexto de manera intensiva; los límites estrictos impiden que las demostraciones se conviertan en facturas inesperadas.
El veredicto
La etapa de The Verdict funciona mejor cuando se trata como una superficie medible. Capture un registro exitoso, un caso de fallo y la nota de reversión antes de ampliar el alcance. Mantenga la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos secretos y las banderas de funcionalidad deben estar en un lugar donde los operadores puedan auditarlos sin tener que leer todo el grafo. Mantenga el estado del grafo simple y tipado. Los bloques anidados ocultan qué nodo escribió qué campo y causan interrupciones en la continuación del proceso.
Parte 2: Preparación del hardware y configuración de inferencia local
La etapa de Preparación de Hardware de la Parte 2 funciona mejor cuando se trata como una superficie medible. Capture un registro exitoso, un caso de fallo y la nota de reversión antes de ampliar el alcance. Documente tanto el camino óptimo como el camino de recuperación juntos. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras posteriores. Mantenga el estado de los gráficos simple y tipado. Los bloques anidados ocultan qué nodo escribió qué campo y provocan interrupciones en la continuación después de las interrupciones.
Paso 1: Instale Ollama — Su motor de inferencia local
La etapa de Instalación de Ollama en el Paso 1 funciona mejor si se trata como una superficie medible. Capture un registro exitoso, un caso de fallo y la nota de reversión antes de ampliar el alcance. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando un paso falla, el fallo debe apuntar a una sola responsabilidad y no a un proceso complicado. Fije el intérprete y el archivo de bloqueo de dependencias antes de explicar el bucle. La diferencia entre el portátil y los entornos CI es la causa más común de fallos silenciosos en las demostraciones de API.
Instalación en Linux
La etapa de instalación de Linux funciona mejor cuando se trata como una superficie medible. Capture una transcripción ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Trate esta etapa como un contrato entre las entradas y los resultados validados. Asigne nombres a los artefactos, defina verificaciones de éxito y rechace completaciones parciales silenciosas. Mantenga el estado del grafo plano y tipado. Los bloques anidados ocultan qué nodo escribió qué campo y provocan interrupciones en la continuación posterior.
curl -fsSL https://ollama.com/install.sh | sh
Instalación en macOS
La etapa de instalación de macOS funciona mejor cuando se trata como un área medible. Capture una transcripción ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Registre los tiempos y el costo de tokens o consultas junto con los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando se pasa de la versión de demostración a entornos compartidos. Mantenga el estado del gráfico simple y estructurado. Los bloques anidados ocultan qué nodo escribió qué campo y causan interrupciones en la continuación del proceso. La etapa de instalación de macOS funciona mejor cuando se trata como un área medible. Capture una transcripción ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Documente tanto el camino óptimo como el camino de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son ajustes realizados posteriormente.
curl -fsSL https://ollama.com/install.sh | sh
Instalación en Windows
En la fase de instalación en Windows, defina las entradas, el responsable del paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido, sin tener que adivinar el estado oculto. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando un paso falla, el error debe indicar una única responsabilidad y no un proceso complicado. Incluya la aprobación humana en aquellos casos en que se gastan fondos o se modifican datos de producción. La configuración en tiempo de compilación no equivale a la completitud del proceso empresarial.
irm https://ollama.com/install.ps1 | iex
Verificar la instalación
En la fase de Verificación de Instalación, defina las entradas, el responsable del paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido sin tener que adivinar el estado oculto. Considere esta fase como un contrato entre las entradas y los resultados validados. Asigne nombres a los artefactos, defina comprobaciones de éxito y rechace las completaciones parciales silenciosas. Incluya la aprobación humana en aquellos casos que impliquen gastos o cambios en los datos de producción. La conexión en tiempo de compilación no equivale a la completitud del proceso empresarial.
ollama --version
ollama version is 0.5.x
Paso 2: Descargue su modelo
En la Etapa 2 “Pull Your stage”, defina las entradas, el responsable de la etapa y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la etapa a partir de un punto de control conocido sin tener que adivinar el estado oculto. Registre los tiempos de ejecución y el costo de tokens o consultas junto con los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando el flujo pasa de entornos de demostración a entornos compartidos. Prefiera salidas estructuradas con validación de esquema sobre texto libre cuando el siguiente paso sea escribir código o realizar una llamada a una herramienta. En la Etapa 2 “Pull Your stage”, defina las entradas, el responsable de la etapa y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la etapa a partir de un punto de control conocido sin tener que adivinar el estado oculto. Documente tanto la ruta óptima como la ruta de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son algo que se añada posteriormente.
# For the winner
ollama pull qwen3.5:9b-q4_K_M
# For speed
ollama pull qwen3.5:4b
# For reasoning
ollama pull gemma4:e4b-q4_K_M
Paso 3: Iniciar el servidor Ollama
Al trabajar en la etapa del Paso 3 de inicio, anote primero el contrato: las entradas requeridas, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación ayuda a mantener honestas las futuras modificaciones del código. Prefiera unidades pequeñas y probables sobre scripts extensos. Cuando un paso falla, el fallo debe apuntar a una única responsabilidad y no a un proceso complicado. Registre el ID de la solicitud, el ID del modelo y la latencia en cada llamada. Sin ese registro, los errores intermitentes del proveedor parecen bugs de la aplicación.
ollama serve
Paso 4: Probar su modelo
Al trabajar en la fase 4 “Prueba”, anote primero el contrato: los datos de entrada requeridos, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación ayuda a mantener honestos los cambios posteriores en el código. Considere esta fase como un contrato entre las entradas y las salidas validadas. Asigne nombres a los artefactos, defina las comprobaciones de éxito y evite completaciones parciales silenciosas. Almacene en caché las instrucciones del sistema estables y los esquemas de las herramientas. Reenviar un preámbulo idéntico es una causa común de problemas.
ollama run qwen3.5:9b-q4_K_M "Hello, introduce yourself briefly."
Parte 3: Configuración de CrewAI — El marco de orquestación
Al trabajar en la etapa de Configuración de la Parte 3, anote primero el contrato: los datos necesarios, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación garantiza que los cambios posteriores en el código sean transparentes. Registre los tiempos y el costo de tokens o consultas junto con los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando el proceso pasa de la versión de demostración a entornos compartidos. Haga una verificación después de los pasos costosos. La función de reanudación no debe volver a facturar la misma llamada al LLM cuando un operador intenta nuevamente un nodo posterior. Al trabajar en la etapa de Configuración de la Parte 3, anote primero el contrato: los datos necesarios, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación garantiza que los cambios posteriores en el código sean transparentes. Documente tanto la ruta óptima como la ruta de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras adicionales realizadas posteriormente.
Requisitos del sistema
La etapa de Requisitos del Sistema funciona mejor cuando se trata como una superficie medible. Capture una transcripción ejemplar, un caso de fallo y la nota de reversión antes de ampliar el alcance. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando un paso falla, el fallo debe apuntar a una única responsabilidad y no a un proceso complicado. Mantenga el estado de los gráficos simple y tipado. Los bloques anidados ocultan qué nodo escribió qué campo y provocan interrupciones en la continuación del proceso.
Paso 1: Instalar uv (El instalador moderno de paquetes para Python)
La Etapa 1 de instalación del entorno UV funciona mejor cuando se trata como una superficie medible. Capture un registro exitoso, un caso de fallo y la nota de reversión antes de ampliar el alcance. Considere esta etapa como un contrato entre las entradas y los resultados validados. Asigne nombres a los artefactos, defina verificaciones de éxito y rechace las completaciones parciales silenciosas. Fije el intérprete y el archivo de bloqueo de dependencias antes de enseñar el bucle; la diferencia entre usar una computadora portátil y un entorno CI es la causa más común de fallos silenciosos en las demostraciones de API.
curl -LsSf https://astral.sh/uv/install.sh | sh
powershell -c "irm https://astral.sh/uv/install.ps1 | iex"
Etapa 2: Instalar CrewAI CLI
La etapa 2 de instalación de CrewAI funciona mejor si se trata como una superficie medible. Capture una transcripción exitosa, un caso de fallo y la nota de reversión antes de ampliar el alcance. Registre los tiempos y el costo en tokens o consultas junto con los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando se pasa de la versión de demostración a entornos compartidos. Mantenga el estado del grafo simple y con tipos definidos; los bloques anidados ocultan qué nodo escribió qué campo y provocan interrupciones en la continuación del proceso.
uv tool install crewai
Paso 3: Cree su proyecto Crew
La Etapa 3, “Crea tu escenario”, funciona mejor cuando se trata como una superficie medible. Captura un registro exitoso, un caso de fallo y la nota de reversión antes de ampliar el alcance. Mantén la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos secretos y las banderas de funcionalidad deben estar en un lugar donde los operadores puedan auditarlos sin tener que leer todo el grafo. Mantén el estado del grafo plano y tipado. Los bloques anidados ocultan qué nodo escribió qué campo y causan interrupciones en la continuación del proceso después de las interrupciones.
crewai create crew my_agent_team
cd my_agent_team
my_agent_team/
├── src/
│ └── my_agent_team/
│ ├── __init__.py
│ ├── crew.py
│ ├── agents.py
│ ├── tasks.py
│ └── main.py
├── .env
└── pyproject.toml
Etapa 4: Instalar dependencias
La etapa 4, Instalar dependencias, funciona mejor si se trata como un proceso medible. Capture una transcripción exitosa, un caso de fallo y la nota de reversión antes de ampliar el alcance. Documente tanto el camino óptimo como el de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras posteriores. Mantenga el estado del grafo simple y tipado; los bloques anidados ocultan qué nodo escribió qué campo y provocan interrupciones en la continuación del proceso.
uv pip install -e .
Paso 5: Instalar herramientas adicionales
La etapa 5, “Instalar elementos adicionales”, funciona mejor si se trata como una superficie medible. Capture un registro exitoso, un caso de fallo y la nota de reversión antes de ampliar el alcance. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando un paso falla, el fallo debe apuntar a una sola responsabilidad y no a un proceso complicado. Exponga herramientas con esquemas limitados y etiquetas claras sobre efectos secundarios. Los administradores necesitan saber qué llamadas modifican el estado antes de aprobarlas automáticamente.
uv pip install crewai-tools langchain-ollama python-pptx
Parte 4: Formar su equipo de agentes
La fase 4, “Construyendo tu escenario”, funciona mejor cuando se trata como una superficie medible. Registra un caso exitoso, un caso de fallo y la nota de reversión antes de ampliar el alcance. Considera esta fase como un contrato entre las entradas y las salidas validadas. Nombra los artefactos, define las verificaciones de éxito y rechaza cualquier completación parcial silenciosa. Mantén el estado del grafo plano y tipado; los bloques anidados ocultan qué nodo escribió qué campo y provocan interrupciones en la continuación del proceso.
La arquitectura
La etapa de Arquitectura funciona mejor cuando se trata como una superficie medible. Capture un registro ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Registre los tiempos y el costo de tokens o consultas junto con los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando el proceso pasa de la demostración a entornos compartidos. Mantenga el estado del grafo simple y tipado; los bloques anidados ocultan qué nodo escribió qué campo y causan interrupciones en la continuación del proceso. La etapa de Arquitectura funciona mejor cuando se trata como una superficie medible. Capture un registro ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Documente junto con ello el camino óptimo y el camino de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son ajustes realizados posteriormente.
Paso 1: Configurar el LLM
En el Paso 1, Configura la etapa: define las entradas, el responsable del paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido, sin tener que adivinar el estado oculto. Es preferible utilizar unidades pequeñas y verificables en lugar de scripts extensos. Cuando un paso falla, el error debe indicar una única responsabilidad y no un proceso complicado. Se prefieren salidas estructuradas con validación de esquema sobre textos en formato libre cuando el paso siguiente sea código o una llamada a una herramienta.
from langchain_ollama import OllamaLLM
def get_llm():
""" Initialize the local LLM for CrewAI."""
return OllamaLLM(
model="qwen3.5:9b-q4_K_M",
base_url="http://localhost:11434",
temperature=0.3, # Lower = more deterministic
top_p=0.9,
)
Paso 2: Define tus agentes
En la Etapa 2, Definir su fase, se deben definir las entradas, el responsable de la etapa y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la etapa a partir de un punto de control conocido sin tener que adivinar el estado oculto. Considere esta fase como un contrato entre las entradas y los resultados validados. Asigne nombres a los artefactos, defina verificaciones de éxito y rechace las completaciones parciales silenciosas. Incluya la aprobación humana en aquellos procesos que generen gastos o modifiquen datos de producción. La conexión en tiempo de compilación no equivale a la completitud del proceso empresarial.
from crewai import Agent
from crewai_tools import SerperDevTool, FileReadTool
from .llm_config import get_llm
# Initialize tools
search_tool = SerperDevTool() # Requires Serper API key (free tier available)
file_tool = FileReadTool()
def create_coding_agent():
"""Agent specialized in writing and reviewing code."""
return Agent(
role="Senior Software Engineer",
goal="Write clean, efficient, and well-documented code that solves the given problem",
backstory="""You are a senior software engineer with 15 years of experience
across multiple programming languages. You specialize in Python, JavaScript,
and system architecture. You write code that is not only functional but
also maintainable and follows best practices.""",
tools=[file_tool], # Can read existing files
llm=get_llm(),
verbose=True,
allow_delegation=False,
)
def create_research_agent():
"""Agent specialized in deep research and report writing."""
return Agent(
role="Lead Research Analyst",
goal="Conduct thorough research and synthesize findings into comprehensive reports",
backstory="""You are a seasoned research analyst with a PhD in Computer Science.
You have expertise in finding, verifying, and synthesizing information from
multiple sources. Your reports are known for their depth, clarity, and
actionable insights.""",
tools=[search_tool], # Can search the web
llm=get_llm(),
verbose=True,
allow_delegation=False,
)
def create_presentation_agent():
"""Agent specialized in creating PowerPoint presentations."""
return Agent(
role="Senior Presentation Designer",
goal="Transform research findings into compelling, visually-appealing PowerPoint presentations",
backstory="""You are a presentation designer with 10 years of experience
creating executive-level decks for Fortune 500 companies. You know how to
structure information for maximum impact and create slides that tell a
compelling story.""",
tools=[], # We'll handle PPT generation separately
llm=get_llm(),
verbose=True,
allow_delegation=False,
)
Etapa 3: Definir sus tareas
En la Etapa 3 “Defina su fase”, defina las entradas, el responsable de la etapa y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la etapa a partir de un punto de control conocido sin tener que adivinar el estado oculto. Registre los tiempos de ejecución y el costo en tokens o consultas junto con los resultados funcionales. La visibilidad temprana de los costos evita facturas inesperadas cuando el proceso pasa de entornos de demostración a entornos compartidos. Incluya la aprobación humana en aquellos casos en que se gastan fondos o se modifican datos de producción. La configuración en tiempo de compilación no equivale a la completitud del proceso empresarial. En la Etapa 3 “Defina su fase”, defina las entradas, el responsable de la etapa y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la etapa a partir de un punto de control conocido sin tener que adivinar el estado oculto. Documente tanto la ruta óptima como la ruta de recuperación. Las intentonas repetidas, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son algo que se añade posteriormente.
from crewai import Task
def create_coding_task(topic, requirements):
"""Task for the coding agent."""
return Task(
description=f"""
Write a Python solution for the following problem:
Topic: {topic}
Requirements: {requirements}
Your response should include:
1. Complete, working Python code
2. Explanation of the approach
3. Time and space complexity analysis
4. Example usage
Make sure the code is production-ready and includes error handling.
""",
expected_output="A complete Python solution with documentation and analysis.",
agent=None, # Will be assigned later
)
def create_research_task(query):
"""Task for the research agent."""
return Task(
description=f"""
Conduct in-depth research on the following topic:
Query: {query}
Your research should cover:
1. Current state of the art
2. Key players and technologies
3. Challenges and limitations
4. Future trends and predictions
5. Actionable recommendations
Cite your sources and provide a well-structured report.
""",
expected_output="A comprehensive research report with citations.",
agent=None, # Will be assigned later
)
def create_presentation_task(research_findings):
"""Task for the presentation agent."""
return Task(
description=f"""
Create a PowerPoint presentation based on the following research:
{research_findings}
The presentation should include:
1. Title slide with a compelling title
2. Executive summary
3. Key findings (3-5 slides)
4. Visual data representation
5. Recommendations
6. Conclusion and next steps
Provide a detailed outline and slide content.
""",
expected_output="A detailed PowerPoint presentation outline with slide content.",
agent=None, # Will be assigned later
)
Paso 4: Orquestar al equipo
Al trabajar en el Paso 4 de orquestación, anote primero el contrato: los datos necesarios, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación ayuda a mantener honestas las futuras modificaciones del código. Prefiera unidades pequeñas y verificables en lugar de scripts extensos. Cuando un paso falla, el fallo debe apuntar a una sola responsabilidad y no a un proceso complicado. Haga una verificación después de los pasos costosos. El sistema de reanudación no debe volver a facturar la misma llamada al LLM cuando un operador intente nuevamente un nodo posterior.
from crewai import Crew, Process
from .agents import (
create_coding_agent,
create_research_agent,
create_presentation_agent
)
from .tasks import (
create_coding_task,
create_research_task,
create_presentation_task
)
def create_crew(topic, query, requirements):
"""Create and configure the multi-agent crew."""
# Initialize agents
coding_agent = create_coding_agent()
research_agent = create_research_agent()
presentation_agent = create_presentation_agent()
# Create tasks
coding_task = create_coding_task(topic, requirements)
research_task = create_research_task(query)
# Assign agents to tasks
coding_task.agent = coding_agent
research_task.agent = research_agent
# The presentation task depends on research findings
# We'll create it dynamically after research is complete
return Crew(
agents=[coding_agent, research_agent, presentation_agent],
tasks=[coding_task, research_task],
process=Process.sequential, # Tasks run in order
verbose=True,
)
def run_crew(topic, query, requirements):
"""Run the multi-agent crew and return results."""
crew = create_crew(topic, query, requirements)
result = crew.kickoff()
return result
Paso 5: Punto de entrada principal
Al trabajar en la Etapa 5, La fase principal, anote primero el contrato: los datos de entrada requeridos, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación garantiza que los cambios posteriores en el código sean transparentes. Considere esta fase como un contrato entre las entradas y las salidas validadas. Asigne nombres a los elementos generados, defina comprobaciones de éxito y evite completaciones parciales silenciosas. Haga una verificación después de los pasos costosos. La función de reanudación no debe volver a facturar la misma llamada al LLM cuando un operador intente nuevamente un nodo posterior.
import os
from .crew import run_crew
def main():
"""Main entry point for the multi-agent system."""
# Define your project
topic = "Building a REST API with FastAPI"
query = "Best practices for FastAPI REST API development in 2026"
requirements = """
- Python 3.11+
- FastAPI framework
- PostgreSQL database
- JWT authentication
- Docker deployment
"""
print("🚀 Starting multi-agent workflow...")
print("=" * 50)
# Run the crew
result = run_crew(topic, query, requirements)
print("\n✅ Workflow complete!")
print("=" * 50)
print("\n📊 Results:")
print(result)
return result
if __name__ == "__main__":
main()
Parte 5: Generación automática de PowerPoint
Al trabajar en la fase de Generación automática de PowerPoint de la Parte 5, anote primero el contrato: los datos de entrada requeridos, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación garantiza que los cambios posteriores en el código sean transparentes.
Etapa 1: Crear el generador de PPT
from pptx import Presentation
from pptx.util import Inches, Pt
from pptx.enum.text import PP_ALIGN
from pptx.dml.color import RGBColor
import os
def create_presentation_from_content(content, filename="presentation.pptx"):
"""
Generate a PowerPoint presentation from structured content.
Args:
content: Dictionary with slide titles and content
filename: Output filename
"""
prs = Presentation()
# Set slide dimensions (16:9)
prs.slide_width = Inches(13.333)
prs.slide_height = Inches(7.5)
# Title Slide
title_slide_layout = prs.slide_layouts[0]
slide = prs.slides.add_slide(title_slide_layout)
slide.shapes.title.text = content.get("title", "AI-Generated Presentation")
slide.placeholders[1].text = content.get("subtitle", "Powered by CrewAI + Ollama")
# Content Slides
for slide_data in content.get("slides", []):
bullet_slide_layout = prs.slide_layouts[1]
slide = prs.slides.add_slide(bullet_slide_layout)
# Title
slide.shapes.title.text = slide_data.get("title", "Untitled")
# Content
content_text = slide.placeholders[1]
content_frame = content_text.text_frame
content_frame.clear()
for point in slide_data.get("points", []):
p = content_frame.add_paragraph()
p.text = point
p.level = 0
p.font.size = Pt(18)
# Save
prs.save(filename)
print(f"✅ Presentation saved as: {filename}")
return filename
def generate_ppt_from_research(research_text, topic):
"""
Generate a PPT from research findings using the presentation agent.
"""
from .agents import create_presentation_agent
from .llm_config import get_llm
# Have the presentation agent structure the content
agent = create_presentation_agent()
prompt = f"""
Based on the following research about "{topic}", create a structured
presentation outline with 6-8 slides.
Research:
{research_text[:2000]} # Limit to avoid context overflow
Return a JSON object with the following structure:
{{
"title": "Presentation title",
"subtitle": "Subtitle or tagline",
"slides": [
{{
"title": "Slide title",
"points": ["Point 1", "Point 2", "Point 3"]
}}
]
}}
"""
# Get structured output from the agent
response = agent.llm.invoke(prompt)
# Parse the response (simplified - in production, use proper JSON parsing)
import json
try:
# Extract JSON from response
content = json.loads(response)
except:
# Fallback: create a simple structure
content = {
"title": f"Research on {topic}",
"subtitle": "AI-Generated Presentation",
"slides": [
{"title": "Introduction", "points": ["Overview of research"]},
{"title": "Key Findings", "points": ["Finding 1", "Finding 2"]},
{"title": "Recommendations", "points": ["Recommendation 1"]}
]
}
# Generate the PPT
filename = f"{topic.replace(' ', '_')}_presentation.pptx"
return create_presentation_from_content(content, filename)
Etapa 2: Integrar la generación de PPT en Crew
from .ppt_generator import generate_ppt_from_research
def run_full_workflow(topic, query, requirements):
"""Run the complete workflow including PPT generation."""
# Step 1: Run the crew (coding + research)
crew_result = run_crew(topic, query, requirements)
# Step 2: Extract research findings (simplified - in production, parse properly)
research_findings = crew_result # This would be the research agent's output
# Step 3: Generate PowerPoint
ppt_file = generate_ppt_from_research(research_findings, topic)
return {
"crew_result": crew_result,
"presentation_file": ppt_file
}
Parte 6: Errores comunes y cómo solucionarlos
Problema 1: “Connection refused” cuando CrewAI intenta conectarse a Ollama
litellm.APIConnectionError: OllamaException - [Errno 111] Connection refused
llm = OllamaLLM(
model="qwen3.5:9b-q4_K_M",
base_url="http://localhost:11434", # Ensure this is correct
)
Problema 2: El modelo no sigue los esquemas de llamada a herramientas
Problema 3: Errores de falta de memoria (OOM)
Problema 4: El agente se queda atascado en bucles recursivos
Problema 5: Generación lenta de tokens
Parte 7: Ejecutando tu primer flujo de trabajo multiagente
La configuración completa
#!/usr/bin/env python3
"""
Complete Multi-Agent System with Ollama and CrewAI
"""
import os
import sys
from src.my_agent_team.crew import run_full_workflow
def main():
print("""
╔═══════════════════════════════════════════════════════╗
║ 🤖 Multi-Agent AI System - Local Edition ║
║ Powered by Ollama + CrewAI + Qwen3.5:9b ║
╚═══════════════════════════════════════════════════════╝
""")
# Check if Ollama is running
import requests
try:
response = requests.get("http://localhost:11434")
print("✅ Ollama is running!")
except:
print("❌ Ollama is not running. Please start it with: ollama serve")
sys.exit(1)
# Define your project
topic = input("Enter your project topic (e.g., 'Building a REST API with FastAPI'): ")
query = input("Enter your research query (e.g., 'Best practices for FastAPI'): ")
requirements = input("Enter your requirements (e.g., 'Python, PostgreSQL, JWT'): ")
print("\n🚀 Starting multi-agent workflow...")
print("=" * 60)
try:
result = run_full_workflow(topic, query, requirements)
print("\n✅ Workflow complete!")
print("=" * 60)
print(f"\n📄 Presentation saved as: {result['presentation_file']}")
print("\n📊 Crew Results:")
print(result['crew_result'])
except Exception as e:
print(f"\n❌ Error: {e}")
print("\n💡 Troubleshooting tips:")
print("1. Make sure Ollama is running: ollama serve")
print("2. Check if the model is downloaded: ollama list")
print("3. Ensure you have enough memory (close other apps)")
print("4. Check the error message above for specific issues")
if __name__ == "__main__":
main()
¡Ejecútalo!
python run.py