Construyendo un agente de IA con Lumbre 4 y autógeno

La clan de modelos LLAMA 4 de Meta’s está descartando el mundo siempre innovador de la IA. Estos modelos están revolucionando cómo construimos sistemas inteligentes con sus capacidades multimodales nativas. Cuando LLAMA 4 Combina con el autógeno, desbloquea todo el potencial de construir agentes de IA dinámicos, receptivos y robustos. Aprovechando la integración entre Lumbre 4 y Autógenolos desarrolladores pueden crear agentes de IA innovadores que puedan razonar, colaborar y adaptarse de guisa capaz. En este artículo, aprenderemos cómo construir agentes de IA con Lumbre 4 y Autógen para aplicaciones específicas.

¿Por qué deberíamos considerar usar Lumbre 4?

La Grupo Maniquí de Lumbre 4, incluidas las variantes Scout y Maverick, representa un brinco significativo delante en la tecnología de IA de código extenso. Estos modelos ofrecen varias ventajas secreto:

• Inteligencia multimodal: Lumbre 4 presenta capacidades multimodales nativas que integran diferentes tipos de entrada en una obra unificada. Esto permite un razonamiento más sofisticado en diferentes tipos de medios.
• Gran distancia del contexto: Admite hasta 10 millones de tokens, expandiendo Lumbre 3‘s 128k tope. Permite el manejo de contextos excepcionalmente largos. Esto hace posibles aplicaciones avanzadas como estudio integral de documentos múltiples, personalización extensa basada en el historial de usuarios y la navegación de grandes bases de código.
• Rendimiento capaz: Lumbre 4 emplea una mezcla de obra experta que activa solo porciones específicas del maniquí para cada token procesado. Este enfoque hace que los modelos sean mucho eficientes. Lumbre 4 Maverick, por ejemplo, utiliza solo 17 mil millones de sus 400 mil millones de parámetros durante la operación. Esto le permite ejecutarse en un solo host H100 DGX.
• Rendimiento y capacidades superiores: La prueba de relato muestra LLAMA 4 Maverick superando modelos comparables como GPT-4O y Gemini 2.0 a través de la codificación, el razonamiento, las capacidades multilingües y la comprensión de las imágenes.
• Código extenso y accesible: Meta está poniendo a disposición modelos para descargar. Esto fomenta la innovación abierta, permitiendo a los desarrolladores personalizar e implementar la tecnología en diversas aplicaciones y plataformas.

Lea asimismo: Deepseek v3 vs.candela 4: Designar el maniquí AI adecuado para ti

LLAMA 4 RENDIMIENTO DE REPORTACIÓN

Para comprender cuán bueno es este maniquí, aquí hay una comparación de Lumbre 4 contra otros modelos principales en varios puntos de relato tipificado.

Lea asimismo: Lumbre 4 vs. GPT-4O: ¿Cuál es mejor para los trapos?

Construir un agente de IA usando Lumbre 4

En esta sección, lo guiaré a través del proceso de construcción de agentes específicos de tareas utilizando LLAMA 4 y Autogen. Crearemos un sistema de múltiples agentes que analice los requisitos del cliente para un trabajo, encuentre a los trabajadores independientes para el trabajo particular en función de su experiencia y detalles, y luego genera propuestas de trabajo personalizadas para que el afortunado los envíe. Así que comencemos.

Lea asimismo: Práctico habilidad para construir chatbots de múltiples agentes con autógeno

Paso 0: Configuración del entorno

Antaño de construir el agente, primero cubriremos los requisitos previos necesarios y estableceremos el medio concurrencia.

Requisitos previos

Penetrar a la API

Usaremos la API Together aquí para obtener al maniquí LLAMA 4. Cree una cuenta en Together AI y visite esta página para crear su secreto secreta: https://api.together.xyz/

Paso 1: Configuración de bibliotecas y herramientas para regir a los agentes de IA

Primero, importaremos todas las bibliotecas y herramientas necesarias que necesitaremos aquí.

import os
import autogen
from IPython.display import display, Markdown

Paso 2: convocar a la API

Para usar la Lumbre 4, tenemos que cargar la API juntas. El pedrusco de código a continuación nos ayudará a cargar las API y configurarlas en el entorno.

with open("together_ai_api.txt") as file:
   LLAMA_API_KEY = file.read().strip()
os.environ("LLAMA_API_KEY") = LLAMA_API_KEY

Paso 3: Crear agentes y aclarar tareas

Ahora, creemos los agentes requeridos y definamos sus tareas, es asegurar, lo que harán.

1. Agente de entrada del cliente

El agente de entrada del cliente actúa como la interfaz principal entre el afortunado humano y el sistema de agentes. Recopila detalles del tesina como requisitos del cliente, renglón de tiempo y presupuesto del afortunado y los pasa al arquitecto de resonancia. Asimismo transmite preguntas y respuestas de seguimiento, y señala la terminación cuando se acepta la propuesta final.

Salida esperada:

• Transmisión clara de la descripción del tesina del afortunado y el perfil de freelancer (habilidades, experiencia, estimación de tiempo).
• Finaliza la sesión una vez que se entrega una propuesta satisfactoria, o el afortunado la terminará explícitamente.

# Agent 1: Handles Human Input for Client Requirements
client_agent = autogen.UserProxyAgent(
   name="Client_Input_Agent",
   human_input_mode="ALWAYS",  # asks the human for input
   max_consecutive_auto_reply=1, # Only reply merienda
   is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
   system_message="""You are the primary point of contact for the user.
   Your first task is to provide the initial project details received from the human user (client requirements, product details, timeline, budget) to the group chat.
   After the Scope Architect asks questions, relay the human user's answers about their skills, experience, tools, and time estimate back to the chat.
   Reply TERMINATE when the final proposal is generated and satisfactory, or if the user wishes to stop. Otherwise, relay the user's input.
   """,
)

2. Agente de arquitecto de resonancia

El agente de arquitecto de ámbitos es responsable de los detalles iniciales del tesina del agente de entrada del cliente. A posteriori de eso, hace preguntas específicas para reunir las habilidades, las herramientas, la experiencia del tesina pasada y el tiempo estimado para completar el trabajo. No procede a la coexistentes de propuestas en sí misma, pero asegura que todo el contexto necesario se recopile antaño de entregarlo al subsiguiente agente.

Salida esperada:

• Recopilación acertadamente estructurado que combina las micción del tesina del cliente y las capacidades del freelancer.
• Desencadena el agente de recomendación de tarifa una vez que se recopilan y recapitulación todos los datos requeridos.

# Agent 2: Gathers User's Profile and Estimates
scope_architect_agent = autogen.AssistantAgent(
   name="Scope_Architect",
   llm_config=llm_config,
   human_input_mode="ALWAYS",
   max_consecutive_auto_reply=1, # Only reply merienda 
   is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
   system_message="""You are a Scope Architect. Your role is to understand the project requirements provided initially and then gather necessary details *from the Client_Input_Agent (representing the user/freelancer)*.
   1. Wait for the initial project details from Client_Input_Agent.
   2. Merienda you have the project details, formulate clear questions for the Client_Input_Agent to ask the human user about their:
       - Relevant past work/projects and collaborations.
       - Key skills and tools applicable to this project.
       - Their estimated time to complete the defined work.
   3. Do NOT proceed to proposal generation. Wait for the Client_Input_Agent to provide the user's answers.
   4. Merienda you have both the client requirements AND the user's details (skills, experience, time estimate), summarize this information clearly for the Rate Recommender. Signal that you have all necessary info.
   """,
)

3. Agente de recomendación de tasa

El agente de recomendación de tarifas utiliza la información recopilada para ocasionar una propuesta de tesina detallada. Demora el recapitulación completo del arquitecto de resonancia. Luego analiza el resonancia del tesina y los detalles de Freelancer para ocasionar un documento de propuesta profesional. Esto incluye una presentación personalizada, una renglón de tiempo, niveles de precios múltiples y un claro llamado a la argumento.

Salida esperada:

• Documento de propuesta de tesina formateado profesionalmente con un resonancia, precios y próximos pasos.
• La salida final está repertorio para ser entregada al cliente para su aprobación o discusión adicional.

rate_recommender_agent = autogen.AssistantAgent(
   name="Rate_Recommender",
   llm_config=llm_config,
   max_consecutive_auto_reply=1, # Only reply merienda
   system_message=f"""
You are a Proposal Generator and Rate Recommender. Your task is to create a structured project proposal.
Wait until the Scope_Architect shares a summary containing BOTH the client's project requirements AND the user's profile (skills, experience, time estimate, past work if available).
Analyze all received data: client needs, user expertise, estimated time, and any prior rate insights.
Generate a well-structured proposal addressed to the client, including the following sections:
Custom Introduction: Professionally introduce the user's services and reference the client's company and project.
Project Scope & Timeline: Clearly outline the deliverables with estimated timelines based on user input.
Suggested Pricing Tiers: Provide 1–3 pricing options (hourly, fixed fee, retainer) with justifications based on scope, user experience, or complexity.
Next Steps (CTA): Recommend scheduling a brief kickoff call to finalize and clarify details.
Present ONLY the final formatted proposal. Do not include additional commentary unless clarification is requested.""",)

4. Agente proxy de afortunado

Este agente actúa como un punto de entrada o ayudante para comenzar la interacción. Aunque no juega un papel central en este flujo (basado en el código proporcionado), podría estilarse para iniciar o ayudar con las tareas orientadas al afortunado.

user_proxy = autogen.UserProxyAgent(
   name="user_proxy",
   max_consecutive_auto_reply=1,
   # is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
   llm_config=llm_config,
   system_message="""you are an helpful assistant and initate the conversation"""
)

Paso 4: Creación del regente del rama

Este paso establece el coordinador central que administra la comunicación y el trabajo en equipo entre todos los agentes especializados.

1. Configuración del chat grupal

El chat grupal establece un entorno de conversación estructurado para tres agentes especializados. Estos son el agente del cliente, el agente de arquitecto de resonancia y el agente de recomendación de calificaciones. Gestiona el flujo de conversación a través de los límites redondos y la selección ordenada de los altavoces.

Puntos secreto:

• Alberga tres agentes especializados que trabajan para la creación de propuestas
• Cuatro rondas como mayor para perseverar el enfoque
• El patrón de acento «Round_robin» asegura una décimo ordenada
• Crea un entorno controlado para compendiar información

# --- Group Chat Setup ---
groupchat = autogen.GroupChat(
   agents=(client_agent, scope_architect_agent, rate_recommender_agent),
   messages=(),
   max_round=4,
   speaker_selection_method="round_robin",
)

2. Creación del regente de chat grupal

El regente de chat grupal comparsa toda la conversación, guiando las interacciones a través de una progresión método de los detalles del tesina a la coexistentes de propuestas. Su mensaje del sistema proporciona instrucciones paso a paso para las interacciones de los agentes y define las condiciones claras de terminación.

Puntos secreto:

• Dirige el flujo de conversación entre todos los agentes
• Enlaces al objeto de chat grupal
• Mantiene una configuración de LLM consistente
• Contiene instrucciones de proceso detalladas
• Termina al finalizar la propuesta o con el comando terminado

manager = autogen.GroupChatManager(
   groupchat=groupchat,
   llm_config=llm_config,
   # System message for the manager guiding the overall flow
   system_message="""Manage the conversation flow between the agents.
   1. Start with the Client_Input_Agent providing project details.
   2. Ensure the Scope_Architect asks the necessary questions about the user's background.
   3. Ensure the Client_Input_Agent relays the user's answers.
   4. Ensure the Rate_Recommender waits for all info before generating the final proposal in the specified format.
   The conversation finishes when the final proposal is generated or the Client_Input_Agent says TERMINATE."""
)

Paso 5: iniciando el chat

Ahora que tenemos a los agentes en su circunscripción, iniciemos el flujo de trabajo colaborativo entre los agentes. Para esto, enviaremos un mensaje de instrucción claro al GroupChatManager desde el agente user_proxy.

Puntos secreto:

• Desencadena la conversación utilizando user_proxy.initiate_chat (), que inicia el chat del rama y envía el mensaje al rama Chatmanager.
• Delegue el control al administrador, que luego sigue el flujo paso a paso utilizando el método de rotundo y sus instrucciones de mensaje de sistema interno para coordinar a los agentes.

# --- Initiate Chat ---


print("Starting the proposal generation process...")
print("Please provide the initial client and project details when prompted.")


initial_prompt_message = """
Start the process. First, I need the client/project details from the user (via Client_Input_Agent).
Then, Scope_Architect should ask the user (via Client_Input_Agent) about their background.
Finally, Rate_Recommender should generate the proposal.
"""


user_proxy.initiate_chat(
   manager,
   message=initial_prompt_message
)

Paso 6: Formateo de la salida

Este código nos ayudará a presentar la salida en un formato de Markdown (.md).

chat_history = manager.chat_messages(client_agent) # Or potentially just manager.chat_messages if structure differs slightly


# Find the last message from the Rate_Recommender agent
final_proposal_message = None
for msg in reversed(chat_history):
   if msg.get("role") == "assistant" and msg.get("name") == rate_recommender_agent.name:
        if "Custom Introduction:" in msg.get("content", ""):
           final_proposal_message = msg
           break
if final_proposal_message:
   final_proposal_string = final_proposal_message.get("content", "Proposal content not found.")
   try:
       display(Markdown(final_proposal_string))
   except NameError:
       print("n(Displaying raw Markdown text as rich output is unavailable)n")
       print(final_proposal_string)


else:
   print("nCould not automatically extract the final proposal from the chat history.")
   print("You may need to review the full chat history above.")

Salida de muestra

Conclusión

En este artículo, creamos un agente de propuestas de tesina utilizando LLAMA 4 y Autogen. El agente reunió efectivamente los requisitos del cliente, estructuró la propuesta y entregó un documento profesional con precios claros y desgloses de la renglón de tiempo. El autógeno manejó el flujo de conversación, mientras que Lumbre 4 aseguró las respuestas naturales y conscientes del contexto en todo momento. Esta colaboración simplificó la comunicación del cliente, que ofrece una opción simplificada para freelancers y consultores para automatizar la coexistentes de propuestas con una entrada manual mínima.

Lumbre 4 mejoró el rendimiento del agente con su mejor instrucción, mejor retención de contexto y educación capaz de pocos disparos. Su capacidad para perseverar la coherencia en los diálogos de múltiples vueltas hizo que el proceso de coexistentes de propuestas fuera más inteligente y receptivo. Adicionalmente, la inferencia rápida y el bajo costo del maniquí lo hicieron adecuado para aplicaciones en tiempo auténtico. Juntos, Lumbre 4 y Autogen permiten flujos de trabajo de agentes poderosos que aumentan la productividad y la profesionalidad en las tareas orientadas al cliente.

Preguntas frecuentes