აღნაგობა AI აგენტები Llama 4-ით და AutoGen-ით: ეტაპობრივი ინსტრუქცია

მეტას შერწყმა's Llama 4 მოდელები Microsoft-ით's AutoGen ჩარჩო ახალ შესაძლებლობებს ხსნის ჭკვიანი და ეფექტური შექმნისთვის. AI აგენტები. ეს ტექნოლოგიები, გაერთიანების შემთხვევაში, დეველოპერებს საშუალებას აძლევს შექმნან აპლიკაციები, რომლებსაც შეუძლიათ ბუნებრივი ენის დამუშავება, სურათების გაგება, რთული პრობლემების გადაჭრა და სხვა აგენტებთან თანამშრომლობა ამოცანების შესასრულებლად.

ლამა 4 მოაქვს შთამბეჭდავი მულტიმოდალური შესაძლებლობები და ვრცელი კონტექსტური ფანჯრები, ხოლო ავტოგენი უზრუნველყოფს სტრუქტურირებულ ჩარჩოს მრავალი აგენტის თანამშრომლობით სამუშაო პროცესებში ორკესტრირებისთვის. ერთად, ისინი ქმნიან ძლიერ ინსტრუმენტებს ახალი თაობისთვის. AI განაცხადების.

ეს სახელმძღვანელო გადის პროცესს შენობა AI აგენტები, რომლებიც იყენებენ ამ ინსტრუმენტებს, პრაქტიკული კოდის მაგალითებით და განხორციელების სტრატეგიებით ყველა უნარების დონის დეველოპერებისთვის.

პრაქტიკული მასალის შექმნა AI აგენტის სისტემა

მიადევნე's შექმენით მრავალაგენტური სისტემა, რომელიც დაეხმარება ფრილანსერებს მორგებული სამუშაო შეთავაზებების გენერირებაში. ჩვენი სისტემა:

1. შეაგროვეთ კლიენტის მოთხოვნები
2. შეაგროვეთ ფრილანსერის კვალიფიკაცია
3. შექმენით პროფესიული წინადადებები შესაბამისი ფასებით.

ნაბიჯი 0: თქვენი გარემოს დაყენება

პირველ რიგში დააინსტალირეთ საჭირო პაკეტები:

პითონი

pip install autogen-agentchat~=0.2

pip install ipython

ნაბიჯი 1: API Access-ის კონფიგურაცია

ჩვენ გამოვიყენებთ Together API-ს Llama 4-ზე წვდომისთვის:

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: სპეციალიზებული აგენტების შექმნა

ჩვენს სისტემას სჭირდება სამი განსხვავებული აგენტი კონკრეტული როლებით:

კლიენტის შეყვანის აგენტი

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."""

)

ეს აგენტი ემსახურება როგორც ხიდი ადამიანსა და მომხმარებელს შორის. AI სისტემა, ინფორმაციის შეგროვება და საბოლოო შედეგის წარდგენა.

Scope Architect აგენტი

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."""

)

Scope Architect ფუნქციონირებს როგორც მოთხოვნების ანალიტიკოსი, აგროვებს გადამწყვეტ ინფორმაციას, რომელიც საჭიროა ზუსტი წინადადებისთვის.

შეაფასეთ სარეკომენდაციო აგენტი

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."""

)

ეს აგენტი აწარმოებს საბოლოო მიწოდებას, გარდაქმნის შეგროვებულ ინფორმაციას სტრუქტურირებულ წინადადებად.

ნაბიჯი 3: დამხმარე აგენტის შექმნა (სურვილისამებრ)

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: ჯგუფური ჩატის დაყენება

ახლა ჩვენ შევქმნით საუბრის გარემოს, სადაც აგენტებს შეუძლიათ თანამშრომლობა:

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."""

)

ეს კონფიგურაცია უზრუნველყოფს ორგანიზებულ საუბრის ნაკადს მკაფიო როლებითა და პასუხისმგებლობებით.

ნაბიჯი 5: საუბრის დაწყება

მიადევნე's ჩვენი აგენტის სამუშაო პროცესის დაწყება:

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: საბოლოო წინადადების მოპოვება

საუბრის დასრულების შემდეგ, ჩვენ ამოვიღებთ და გამოვაჩენთ საბოლოო წინადადებას:

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.")

გაუმჯობესებული ტექნიკები უკეთესის შესაქმნელად AI აგენტები

მიუხედავად იმისა, რომ ჩვენი საბაზისო იმპლემენტაცია კარგად მუშაობს, აქ მოცემულია რამდენიმე მოწინავე მიდგომა, რათა თქვენი AI უფრო ძლიერი აგენტები:

A.გარე ხელსაწყოების ინტეგრაცია

AutoGen-ის ერთ-ერთი ძლიერი მხარე აგენტების გარე ინსტრუმენტებით აღჭურვის შესაძლებლობაა. აი, როგორ მისცეთ თქვენს Rate Recommender-ის ბაზრის კვლევის შესაძლებლობები:

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}

)

ეს გაფართოება საშუალებას აძლევს განაკვეთის რეკომენდაციას წვდომა ჰქონდეს გარე ფასების მონაცემებზე, რაც წინადადებებს უფრო ზუსტი და კონკურენტუნარიანი გახდის.

B. მუდმივი მეხსიერების დანერგვა

მეხსიერების შესაძლებლობების დამატება აგენტებს ეხმარება შეინარჩუნონ კონტექსტი მრავალი ურთიერთქმედების დროს:

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)

მეხსიერების ეს სისტემა აგენტებს ეხმარება გაიხსენონ მნიშვნელოვანი ინფორმაცია საუბრის განმავლობაში, მაშინაც კი, როდესაც ცალსახად არ არის აღნიშნული ბოლო შეტყობინებებში.

პრაქტიკული აპლიკაციები წინადადების თაობის მიღმა

ჩვენ მიერ აშენებული არქიტექტურა შეიძლება მოერგოს ბევრ სხვა ბიზნეს სცენარს:

ა. კონტენტის შექმნის მილსადენი

შეცვალეთ ჩვენი აგენტები კონტენტის წარმოების სამუშაო ნაკადების დასამუშავებლად:

B. SEO ანალიზის სისტემა

შექმენით სპეციალიზებული SEO ინსტრუმენტი ამ აგენტებით:

C. მომხმარებელთა მხარდაჭერის ავტომატიზაცია

გარდაქმენით არქიტექტურა დამხმარე სისტემად:

შესრულების ოპტიმიზაციის რჩევები

წარმოებისთვის მზად AI აგენტის სისტემები:

• ჭკვიანი მოდელის შერჩევა: გამოიყენეთ მსუბუქი მოდელები უფრო მარტივი ამოცანებისთვის (მიღება, მარშრუტირება) და შეინახეთ უფრო დიდი მოდელები რთული მსჯელობისთვის (წინადადების შექმნა, ფასი).
• ქეშირების განხორციელება: შეინახეთ ხშირი პასუხები API ზარების შესამცირებლად და პასუხის დროის გასაუმჯობესებლად:

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_response

პარტიული დამუშავება: დამოუკიდებელი დავალებების შემთხვევაში, დაამუშავეთ ისინი პარალელურად და არა თანმიმდევრულად:

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 results

Llama 4-ის ტექნიკური უპირატესობა AI აგენტები

ლამა 4's კონკრეტული მახასიათებლები მას განსაკუთრებით შესაფერისს ხდის აგენტის აპლიკაციებისთვის:

1. ადრეული შერწყმის მულტიმოდალური არქიტექტურა საშუალებას აძლევს აგენტებს ბუნებრივად დაამუშაონ ტექსტი და სურათები ერთად, წინა მიდგომებისგან განსხვავებით, რომლებიც მოდალობას ცალ-ცალკე ინახავდნენ.
2. ექსპერტთა ნაზავი დიზაინი საშუალებას აძლევს მოდელს გაააქტიუროს მხოლოდ შესაბამისი პარამეტრები თითოეული ამოცანისთვის, რაც პასუხებს უფრო სწრაფად და ზუსტს ხდის.
3. განსაკუთრებული გრძელი კონტექსტური დამუშავება (10 მილიონამდე ჟეტონები სკაუტში) აგენტებს საშუალებას აძლევს შეინარჩუნონ საუბრის ისტორია და მიმართონ გრძელ დოკუმენტებს თანმიმდევრულობის დაკარგვის გარეშე.
4. მრავალენოვანი შესაძლებლობები 12 ოფიციალურად მხარდაჭერილ ენაზე აგენტები ხელმისაწვდომი ხდება გლობალური მომხმარებლებისთვის.

ჰეს, შეგიძლია შექმნა AI აგენტები, რომლებიც არა მხოლოდ ესმით და პასუხობენ მოთხოვნებს, არამედ აქტიურად თანამშრომლობენ რთული პრობლემების გადასაჭრელად - ნამდვილად წარმოადგენენ შემდეგ თაობას. AI განაცხადების.

ყველაზე ხშირად დასმული კითხვები

დასკვნა

სამშენებლო AI Llama 4-ისა და AutoGen-ის აგენტები საინტერესო შესაძლებლობებს ქმნის ინტელექტუალური, თანამშრომლობითი სისტემების შესაქმნელად, რომლებსაც შეუძლიათ რთული ამოცანების გადაჭრა. ლამა 4's მულტიმოდალური ინტელექტი და AutoGen's მოქნილი აგენტის ჩარჩო დეველოპერებს სთავაზობს ძლიერ ინსტრუმენტებს შესაქმნელად AI აგენტები, რომლებსაც შეუძლიათ მსჯელობა, თანამშრომლობა და სხვადასხვა სცენართან ადაპტაცია.

ჩვენი მაგალითი პროექტი - მრავალ აგენტიანი წინადადებების გენერატორი - აჩვენებს ამ ტექნოლოგიების მხოლოდ ერთ პრაქტიკულ გამოყენებას. იგივე პრინციპები შეიძლება გამოყენებულ იქნას ავაშენოთ AI კონტენტის შექმნის აგენტები, მონაცემთა ანალიზი, მომხმარებელთა მომსახურება, კვლევა, პროექტის მენეჯმენტი და მრავალი სხვა სფერო.

როგორც კი შენს საკუთარს ააშენებ AI Llama 4-ისა და AutoGen-ის აგენტებისთვის, გახსოვდეთ ეს ძირითადი პრინციპები: