A Meta fúziója's Llama 4 modellek Microsofttal's Az AutoGen keretrendszer új lehetőségeket nyit az intelligens és hatékony AI ágensek. Ezek a technológiák kombinálva lehetővé teszik a fejlesztők számára, hogy olyan alkalmazásokat készítsenek, amelyek képesek feldolgozni a természetes nyelvet, megérteni a képeket, összetett problémákon keresztül érvelni, és más ágensekkel együttműködni a feladatok elvégzésében.
Láma 4 lenyűgöző multimodális képességeket és kiterjedt kontextusablakokat kínál, miközben AutoGen strukturált keretet biztosít több ágens együttműködésen alapuló munkafolyamatokban történő összehangolásához. Együttesen egy hatékony eszközkészletet alkotnak a következő generációs AI alkalmazásokat.
Ez az útmutató végigvezeti a folyamatot épület AI ügynökök, akik ezeket az eszközöket használják, gyakorlati kódpéldákkal és megvalósítási stratégiákkal minden készségszintű fejlesztő számára.
Mitől Láma 4 és a AutoGen a tökéletes párosítás?
meta's A láma 4 család kiemelkedik a többi közül AI világ a maga natív multimodális képességek és a korai fúziós megközelítés. AutoGennel kombinálva –microsoft's keretrendszer párbeszédes többágenses rendszerek építéséhez– a fejlesztők létrehozhatnak AI olyan ágensek, akik hatékonyan gondolkodnak, együttműködnek és alkalmazkodnak.
Llama 4 modellek, beleértve a Scout és a Maverick változatokat is korai fúziós multimodális feldolgozás amely a szöveget, képeket és videókereteket kezdettől fogva egyetlen tokenek sorozataként kezeli. Ez a képesség az AutoGennel párosítva's rugalmas ágensarchitektúra, lehetővé teszi a következők létrehozását AI rendszerek ami képes:
Legyen's Készítsen egy praktikus, többügynökös rendszert, amely bemutatja ezeket a képességeket egy projektjavaslat-generátor létrehozásával, amely elemzi az ügyféligényeket és egyedi állásajánlatokat generál.
Gyakorlati építkezés AI Ügynökrendszer
Legyen's hozzon létre egy többügynökös rendszert, amely segít a szabadúszóknak személyre szabott állásajánlatok generálásában. Rendszerünk a következőket teszi:
- Gyűjtsd össze az ügyfelek igényeit
- Szerezzen szabadúszó képesítéseket
- Professzionális ajánlatok készítése megfelelő árakkal.
0. lépés: A környezet beállítása
Először telepítse a szükséges csomagokat:
piton
pip install autogen-agentchat~=0.2
pip install ipython
1. lépés: Az API-hozzáférés konfigurálása
A Together API-t használjuk a Llama 4 eléréséhez:
python
import os
import autogen
from IPython.display import display, Markdown
# Load API key from file
with open("together_ai_api.txt") as file:
LLAMA_API_KEY = file.read().strip()
os.environ["LLAMA_API_KEY"] = LLAMA_API_KEY
# Configure LLM settings
llm_config = {
"config_list": [
{
"model": "meta-llama/Llama-4-Scout", # Use Scout for efficiency
"api_key": os.environ.get("LLAMA_API_KEY"),
"base_url": "https://api.together.xyz/v1",
}
],
"temperature": 0.2, # Lower for more consistent outputs
"timeout": 180
}2. lépés: Speciális ügynökök létrehozása
Rendszerünknek három különálló ügynökre van szüksége meghatározott szerepkörrel:
Ügyfélbeviteli ügynök
python
# Agent 1: Interfaces with the human user
client_agent = autogen.UserProxyAgent(
name="Client_Input_Agent",
human_input_mode="ALWAYS", # Always gets input from human
max_consecutive_auto_reply=1,
is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
system_message="""Act as the primary contact between the human user and other agents.
First, collect initial project details (requirements, timeline, budget).
When asked questions by the Scope Architect, relay user's answers about skills and experience.
Type TERMINATE when the proposal is satisfactory or the user wants to stop."""
)Ez az ágens hidat képez az emberi felhasználó és a AI rendszer, információk gyűjtése és bemutatjuk a végső kimenetet.
Terjedelem Építész ügynök
python
# Agent 2: Analyzes requirements and asks qualifying questions
scope_architect_agent = autogen.AssistantAgent(
name="Scope_Architect",
llm_config=llm_config,
max_consecutive_auto_reply=1,
system_message="""You are a Scope Architect who analyzes project requirements.
After receiving initial details from Client_Input_Agent, ask targeted questions about:
- The freelancer's relevant past projects and experience
- Their key skills and tools for this specific project
- Estimated completion time for the described work
Once you have sufficient information, create a concise summary of BOTH
the project requirements AND freelancer qualifications for the Rate Recommender."""
)A Scope Architect követelményelemzőként működik, és összegyűjti a pontos ajánlathoz szükséges alapvető információkat.
Rate Recommender Agent
python
# Agent 3: Creates structured proposal with pricing
rate_recommender_agent = autogen.AssistantAgent(
name="Rate_Recommender",
llm_config=llm_config,
max_consecutive_auto_reply=1,
system_message="""Generate professional project proposals based on gathered information.
Wait for the Scope Architect's complete summary before proceeding.
Include these sections in your proposal:
1. Custom Introduction: Personalized greeting referencing client and project
2. Project Scope & Timeline: Clear deliverables with timeline estimates
3. Pricing Options: 2-3 tiers (hourly/fixed/retainer) with justification
4. Next Steps: Brief suggestion for kickoff discussion
Format using proper markdown. Avoid commentary - deliver only the final proposal."""
)Ez az ügynök állítja elő a végső szállítmányt, és az összegyűjtött információkat strukturált ajánlattá alakítja.
3. lépés: Segítő ügynök létrehozása (opcionális)
python
# Optional helper to initiate the conversation
user_proxy = autogen.UserProxyAgent(
name="user_proxy",
max_consecutive_auto_reply=1,
llm_config=llm_config,
system_message="Initiate the conversation between agents."
)4. lépés: A csoportos csevegés beállítása
Most létrehozzuk azt a beszélgetési környezetet, ahol az ügynökök együttműködhetnek:
python
# Group Chat Configuration
groupchat = autogen.GroupChat(
agents=[client_agent, scope_architect_agent, rate_recommender_agent],
messages=[],
max_round=4, # Prevent infinite loops
speaker_selection_method="round_robin", # Orderly participation
)
# Conversation Manager
manager = autogen.GroupChatManager(
groupchat=groupchat,
llm_config=llm_config,
system_message="""Direct the conversation flow through these steps:
1. Client_Input_Agent shares project details
2. Scope_Architect asks qualifying questions
3. Client_Input_Agent provides freelancer information
4. Scope_Architect summarizes all information
5. Rate_Recommender creates the final proposal
End when the proposal is complete or Client_Input_Agent says TERMINATE."""
)Ez a felépítés biztosítja a szervezett beszélgetési folyamatot, egyértelmű szerepekkel és felelősségi körökkel.
5. lépés: A beszélgetés indítása
Legyen's Indítsuk el az ügynöki munkafolyamatunkat:
python
# Begin the proposal generation process
print("Starting the proposal generation process...")
print("Please provide project details when prompted.")
initial_message = """
Begin the proposal creation process:
1. First collect project details from the user
2. Then gather freelancer qualifications
3. Finally generate a professional proposal
"""
user_proxy.initiate_chat(
manager,
message=initial_message
)6. lépés: A végső ajánlat kibontása
A beszélgetés befejeztével kibontjuk és megjelenítjük a végső ajánlatot:
python
# Find and display the proposal
chat_history = manager.chat_messages[client_agent]
final_proposal = None
for msg in reversed(chat_history):
if msg.get("role") == "assistant" and msg.get("name") == rate_recommender_agent.name:
if "Introduction" in msg.get("content", ""):
final_proposal = msg
break
if final_proposal:
proposal_text = final_proposal.get("content", "Proposal not found.")
try:
display(Markdown(proposal_text))
except NameError:
print("\n--- FINAL PROPOSAL ---\n")
print(proposal_text)
else:
print("Could not find the final proposal in the conversation.")Továbbfejlesztett technikák a jobb építéshez AI Ügynökök
Míg az alapvető megvalósításunk jól működik, íme néhány haladó megközelítés, amelyekkel a sajátodat is könnyebbé teheted. AI erősebb ügynökök:
A.Külső eszközök integrációja
Az AutoGen egyik erőssége, hogy külső eszközökkel tudja felszerelni az ügynököket. Így adhatsz piackutatási lehetőségeket a Rate Recommenderednek:
python
# Define function for market research
def research_market_rates(job_type, experience_level):
"""Access external data for pricing information"""
# This would typically connect to an API or database
# Using simple dictionary for demonstration
rate_data = {
"web_development": {
"beginner": "$30-50/hr",
"intermediate": "$50-90/hr",
"expert": "$90-200/hr"
},
"data_analysis": {
"beginner": "$25-45/hr",
"intermediate": "$45-85/hr",
"expert": "$85-180/hr"
}
}
# Retrieve appropriate rate range
try:
return rate_data[job_type][experience_level]
except KeyError:
return "Rate information not available for this combination"
# Configure LLM with function
rate_recommender_config = {
**llm_config,
"functions": [
{
"name": "research_market_rates",
"description": "Find current market rates for specific job types and experience levels",
"parameters": {
"type": "object",
"properties": {
"job_type": {
"type": "string",
"enum": ["web_development", "data_analysis", "content_writing", "graphic_design"]
},
"experience_level": {
"type": "string",
"enum": ["beginner", "intermediate", "expert"]
}
},
"required": ["job_type", "experience_level"]
}
}
]
}
# Update the Rate Recommender with function capabilities
rate_recommender_agent = autogen.AssistantAgent(
name="Rate_Recommender",
llm_config=rate_recommender_config,
system_message="""Generate proposals with accurate market-based pricing.
Use the research_market_rates function to get current pricing information."""
)
# Register the function with the agent
rate_recommender_agent.register_function(
function_map={"research_market_rates": research_market_rates}
)Ez a továbbfejlesztés lehetővé teszi a Rate Recommender számára, hogy hozzáférjen a külső áradatokhoz, így az ajánlatok pontosabbak és versenyképesebbek.
B. Állandó memória megvalósítás
A memóriaképességek hozzáadása segít az ügynököknek a kontextus fenntartásában több interakció során:
python
# Create a simple memory system for agents
class AgentMemory:
def __init__(self):
self.memories = {}
def store(self, agent_name, key, value):
"""Save information to agent memory"""
if agent_name not in self.memories:
self.memories[agent_name] = {}
self.memories[agent_name][key] = value
def retrieve(self, agent_name, key=None):
"""Get information from agent memory"""
if agent_name not in self.memories:
return None
if key:
return self.memories[agent_name].get(key)
else:
return self.memories[agent_name]
# Initialize memory
memory = AgentMemory()
# Example of storing client information
def process_client_input(message):
"""Extract and store client information"""
# This would typically use more sophisticated parsing
if "budget:" in message.lower():
budget = message.split("budget:")[1].strip().split("\n")[0]
memory.store("client", "budget", budget)
if "timeline:" in message.lower():
timeline = message.split("timeline:")[1].strip().split("\n")[0]
memory.store("client", "timeline", timeline)
return message
# Add memory hook to client agent
def memory_hook(recipient, messages, sender, config):
"""Process and store incoming messages"""
if sender.name == "Client_Input_Agent" and messages:
process_client_input(messages[0].get("content", ""))
return False, None # Continue normal processing
# Register the hook
client_agent.register_hook("memory_hook", memory_hook)Ez a memóriarendszer segít az ügynököknek felidézni a fontos információkat a beszélgetés során, még akkor is, ha a legutóbbi üzenetekben nem említik kifejezetten.
Gyakorlati alkalmazások az ajánlatok generálásán túl
Az általunk felépített architektúra sok más üzleti forgatókönyvhöz illeszthető:
A. Tartalomkészítési folyamat
Módosítsa ügynökeinket a tartalomgyártási munkafolyamatok kezelésére:
B. SEO elemző rendszer
Hozzon létre egy speciális SEO eszközt ezekkel az ügynökökkel:
C. Ügyfélszolgálat automatizálása
Alakítsa át az architektúrát támogató rendszerré:
Teljesítményoptimalizálási tippek
Gyártásra kész AI ügynökrendszerek:
- Intelligens modellválasztás: Használjon könnyű modelleket az egyszerűbb feladatokhoz (bevétel, útválasztás), és tartson fenn nagyobb modelleket az összetett érveléshez (ajánlatkészítés, árképzés).
- Gyorsítótárazás megvalósítása: Tárolja a gyakori válaszokat az API-hívások csökkentése és a válaszidő növelése érdekében:
python
# Simple cache implementation
response_cache = {}
def get_cached_response(query_key, generator_function, ttl=3600):
"""Get cached response or generate new one"""
if query_key in response_cache:
timestamp, response = response_cache[query_key]
if time.time() - timestamp < ttl:
return response
# Generate fresh response
new_response = generator_function()
response_cache[query_key] = (time.time(), new_response)
return new_responseKötegelt feldolgozás: Független feladatok esetén párhuzamosan, ne pedig egymás után dolgozza fel őket:
python
import asyncio
async def run_parallel_research():
task1 = asyncio.create_task(research_agent.async_run("Research topic A"))
task2 = asyncio.create_task(research_agent.async_run("Research topic B"))
task3 = asyncio.create_task(research_agent.async_run("Research topic C"))
results = await asyncio.gather(task1, task2, task3)
return resultsA Llama 4 technikai előnye AI Ügynökök
Láma 4's sajátos tulajdonságai különösen alkalmassá teszik ügynöki alkalmazásokhoz:
- Korai fúziós multimodális architektúra lehetővé teszi az ügynökök számára, hogy természetes módon dolgozzák fel a szöveget és a képeket, ellentétben a korábbi megközelítésekkel, amelyek külön tartották a módozatokat.
- Szakértők keveréke lehetővé teszi, hogy a modell csak a releváns paramétereket aktiválja az egyes feladatokhoz, így a válaszok gyorsabbak és pontosabbak.
- Kivételes hosszú kontextus kezelés (akár 10 millió token a Scoutban) lehetővé teszi az ügynökök számára a beszélgetési előzmények megőrzését és a hosszú dokumentumok hivatkozását a koherencia elvesztése nélkül.
- Többnyelvűség 12 hivatalosan támogatott nyelven teszik elérhetővé az ügynököket a globális felhasználók számára.
hes, létrehozhatsz AI olyan ügynökök, akik nemcsak megértik és válaszolnak a kérésekre, hanem aktívan együttműködnek az összetett problémák megoldásában is – valóban a következő generációt képviselve AI alkalmazások.
Legnépszerűbb GYIK
Miben különbözik a Llama 4 a többi nyelvi modelltől?
A Llama 4 korai fúziós megközelítést alkalmaz a multimodális feldolgozáshoz, és ritka Mixture of Experts architektúrát a hatékonyság érdekében. A szöveget, a képeket és a videót egyetlen token sorozatként kezeli, és minden bemenethez csak a releváns „szakértői” almodellt aktiválja.
Működhet az AutoGen a Llama 4-en kívül más LLM-ekkel?
Igen, az AutoGen modellfüggetlen, és különféle LLM-ekkel, beleértve az Open-t is, képes együttműködni.AI modellek, antropikus modellek és más nyílt forráskódú modellek, mint például a Mistral AI vagy a DeepSeek.
Épül AI Az ügynököknek haladó programozási ismeretekre van szükségük?
Nem feltétlenül. Az alapvető Python ismeretekkel és az LLM-ek megértésével beállíthat és futtathat ügynöki munkafolyamatokat. Az AutoGen leegyszerűsíti a több ügynök létrehozásának és koordinálásának folyamatát.
Lehet ezeket AI Az ügynökök helyi hardveren futnak?
Igen, az AutoGen támogatja a helyi LLM-ekkel való integrációt olyan eszközökön keresztül, mint az Ollama, lehetővé téve az ügynökök futtatását a saját hardverén.
Hogyan kezelhetem biztonságosan az API-kulcsokat éles környezetben?
Az API-kulcsokat kód helyett környezeti változókban vagy biztonságos tárolókban tárolja. Használjon megfelelő hitelesítést és titkosítást az éles telepítésekhez.
Bővíthetem az ügynököket egyéni eszközökkel és API-kkal?
Teljesen. Az AutoGen lehetővé teszi ügynökök csatlakoztatását külső API-khoz, adatbázisokhoz és egyéni eszközökhöz, lehetővé téve számukra, hogy különböző rendszerekkel és szolgáltatásokkal kommunikáljanak.
Ajánlott olvasmányok:
Összegzés
Épület AI A Llama 4 és az AutoGen segítségével működő ügynökök izgalmas lehetőségeket nyitnak meg intelligens, együttműködő rendszerek létrehozására, amelyek képesek komplex feladatok elvégzésére. A kombináció a következőkből Láma 4's multimodális intelligencia és AutoGen's rugalmas ágens keretrendszer hatékony eszközöket biztosít a fejlesztőknek az alkotáshoz AI olyan ágensek, akik képesek érvelni, együttműködni és alkalmazkodni a különböző helyzetekhez.
Példaprojektünk – egy többügynököt tartalmazó javaslatgenerátor – ezeknek a technológiáknak csak egy gyakorlati alkalmazását mutatja be. Ugyanezek az elvek alkalmazhatók épít AI tartalomkészítő ügynökök, adatelemzés, ügyfélszolgálat, kutatás, projektmenedzsment és sok más terület.
Ahogy építed a sajátodat AI A Llama 4 és az AutoGen ügynökeinél ne feledkezzenek meg a következő kulcsfontosságú elvekről:
BÓNUSZ: Szerezd meg a 200 dolláros "AI „Mastery Toolkit” INGYENES regisztrációval!
