De zelf-actie AI-gids: begin uw reis naar het bouwen van AI-agenten

Leer de basisbeginselen voor het maken van AI-agenten. Ontdek de hulpmiddelen en technieken die nodig zijn om deze intelligente systemen te ontwerpen en implementeren.

De kunstmatige-intelligentiesector ontwikkelt zich razendsnel. Het is indrukwekkend en vaak verwarrend.

Ik heb gestudeerd, geleerd en een basis gelegd in dit gebied van datawetenschap, omdat ik geloof dat de toekomst van datawetenschap nauw verbonden is met de ontwikkeling van generatieve AI.

Het lijkt alsof het gisteren was dat ik mijn eerste bouwde AI-agentEn twee weken later waren er veel Python-pakketten waaruit je kon kiezen, om nog maar te zwijgen van de no-code-opties die het erg goed deden, zoals n8n.

Van simpele modellen die met ons kunnen chatten tot een tsunami aan AI-agenten die overal zijn, op internet zoeken, bestanden beheren en projecten uitvoeren. Datawetenschap Het hele proces (van het eerste onderzoek naar de gegevens tot het maken van modellen en het evalueren ervan) heeft slechts een paar jaar geduurd.

ماذا؟

Toen ik dit allemaal zag, waren mijn gedachten: “Ik moet zo snel mogelijk meedoen.”. Uiteindelijk is het beter om op de golf mee te surfen, dan erdoor verzwolgen te worden.

Daarom heb ik besloten om deze serie berichten te starten waarin ik van de basis naar het bouwen van onze eerste AI-agent ga en doorloop naar complexere concepten.

Genoeg gepraat, laten we beginnen.

Basisprincipes van AI-agenten

Een AI-agent wordt gemaakt wanneer we een groot taalmodel (LLM) de mogelijkheid geven om te communiceren met tools en acties uit te voeren die nuttig voor ons zijn. In plaats van alleen een chatbot te zijn, kan hij nu afspraken inplannen, onze agenda beheren, op internet zoeken, berichten voor sociale media schrijven, en ga zo maar door... Deze transformatie maakt hem tot een volwaardige digitale assistent.

AI-gestuurde agenten kunnen nuttige dingen doen, meer dan alleen chatten.

Maar hoe kunnen we deze kracht aan een groot taalmodel (LLM) geven?

Het eenvoudige antwoord is om een API te gebruiken om met het grote taalmodel te communiceren. Tegenwoordig zijn er veel Python-pakketten hiervoor. Als je mijn blog volgt, zul je zien dat ik al heb geëxperimenteerd met een aantal pakketten voor het maken van agents: Langchain, Agno (voorheen Phidata) en CrewAI bijvoorbeeld. Voor deze serie blijf ik bij Agno[1].

Stel eerst een virtuele omgeving in met behulp van uv Of Anaconda of uw favoriete omgevingsprocessor. Installeer vervolgens de pakketten.

# Agno AI
pip install agno

# module to interact with Gemini
pip install google-generativeai

# Install these other packages that will be needed throughout the tutorial
 pip install agno groq lancedb sentence-transformers tantivy youtube-transcript-api

Een korte opmerking voordat we verdergaan. Vergeet niet uw Google Gemini API-sleutel [2] aan te vragen.

Het is heel eenvoudig om een eenvoudige proxy te maken. Alle pakketten lijken erg op elkaar. Zij hebben klasse. Agent Of iets dergelijks waarmee we een model kunnen selecteren en met het grotere taalmodel van onze keuze kunnen interacteren. Dit zijn de belangrijkste onderdelen van deze categorie:

model:Maak verbinding met het grote taalmodel. Hier kunnen we kiezen tussen OpenAI, Gemini, Llama, Deepseek, etc.
descriptionMet deze parameter kunnen we het gedrag van de agent beschrijven. Dit wordt toegevoegd aan system_message, wat een soortgelijk medium is.
instructionsIk zie een agent graag als een werknemer of assistent die wij aansturen. Om een taak uit te voeren, moeten we instructies geven over wat er gedaan moet worden. Hier kun je het doen.
expected_outputHier kunnen we instructies geven over het verwachte resultaat.
toolsDit is wat een groot taalmodel tot een agent maakt, waardoor het met behulp van deze hulpmiddelen met de echte wereld kan communiceren.

Laten we nu een eenvoudige agent creëren die geen hulpmiddelen heeft, maar die wel helpt bij het opbouwen van onze intuïtie over de codestructuur.

# Imports
from agno.agent import Agent
from agno.models.google import Gemini
import os

# Create agent
agent = Agent(
    model= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
    description= "An assistant agent",
    instructions= ["Be sucint. Answer in a maximum of 2 sentences."],
    markdown= True
    )

# Run agent
response = agent.run("What's the weather like in NYC in May?")

# Print response
print(response.content)

## ...

In mei kunt u in New York gematigde temperaturen verwachten, meestal tussen de 10 en 25 graden Celsius. Er is kans op regen, dus het is raadzaam om meerdere kledinglagen en een paraplu te dragen.

Dat is geweldig. Wij gebruiken het Gemini 1.5-model. Let op hoe het reageert op basis van de gegevens waarmee het is getraind. Als we hem vragen wat voor weer het vandaag is, krijgen we als antwoord dat hij geen toegang heeft tot internet.

Laten we de bemiddelaars eens bekijken. instructions و expected_output. Nu willen we een tabel met de maand, het seizoen en de gemiddelde temperatuur voor New York City (NYC).

# Imports
from agno.agent import Agent
from agno.models.google import Gemini
import os

# Create agent
agent = Agent(
    model= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
    description= "An assistant agent",
    instructions= ["Be sucint. Return a markdown table"],
    expected_output= "A table with month, season and average temperature",	
    markdown= True
    )

# Run agent
response = agent.run("What's the weather like in NYC for each month of the year?")

# Print response
print(response.content)

En dit is het resultaat.

de maand	seizoen	Gemiddelde temperatuur (°F)
Januari	winter	32
Februari	winter	35
March	de lente	44
April	de lente	54
Mei	de lente	63
Juni	de zomer	72
juli	de zomer	77
Augustus	de zomer	76
September	De herfst	70
Oktober	De herfst	58
November	De herfst	48
December	winter	37

Hulpmiddelen

De bovenstaande antwoorden zijn goed, maar we willen natuurlijk geen krachtige grote taalmodellen (LLM's) gebruiken om met een chatbot te spelen of ons oud nieuws te vertellen, toch?

Wij willen dat het een brug vormt naar automatisering, productiviteit en kennis. Dus je gaat toevoegen Hulpmiddelen mogelijkheden aan onze AI-agenten toe te voegen en zo een brug te slaan naar de echte wereld. Veelvoorkomende voorbeelden van agents zijn: zoeken op internet, SQL uitvoeren, e-mail verzenden of API's aanroepen.

Bovendien kunnen we met elke Python-functie aangepaste functionaliteiten voor onze agenten creëren als hulpmiddel. Hierdoor ontstaan enorme mogelijkheden voor integratie met verschillende systemen en processen.

Hulpmiddelen Het zijn functies die een agent kan uitvoeren om taken uit te voeren.

Qua code is het toevoegen van een widget aan een agent eenvoudigweg een kwestie van het gebruiken van de middleware. tools In de categorie Agent.

Stel je een eenmanszaak voor in de gezondheids- en wellnessbranche die de creatie van content wil automatiseren. Deze persoon plaatst elke dag tips over gezonde gewoontes. Ik weet zeker dat het creëren van content niet zo eenvoudig is als het lijkt. Het vereist creativiteit, onderzoek en copywritingvaardigheden. Als het dus, of in ieder geval een deel ervan, geautomatiseerd kan worden, bespaart het tijd.

We hebben deze code geschreven om een heel eenvoudige agent te maken die een simpele Instagram-post kan maken en deze kan opslaan in een Markdown-bestand ter beoordeling. We hebben het proces teruggebracht van denken > onderzoeken > schrijven > beoordelen > publiceren naar beoordelen > publiceren.

# Imports
import os
from agno.agent import Agent
from agno.models.google import Gemini
from agno.tools.file import FileTools

# Create agent
agent = Agent(
    model= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
                  description= "You are a social media marketer specialized in creating engaging content.",
                  tools=[FileTools(
                      read_files=True, 
                      save_files=True
                      )],
                  show_tool_calls=True)

# Writing and saving a file
agent.print_response("""Write a short post for instagram with tips and tricks
                        that positions me as an authority in healthy eating 
                        and save it to a file named 'post.txt'.""",
                     markdown=True)

Het resultaat is het volgende.

Ontketen uw positieve energie door gezond te eten:

1. Geef prioriteit aan onbewerkte voeding: eet veel fruit, groenten, magere eiwitten en volkoren granen. Ze zijn rijk aan voedingsstoffen en zorgen ervoor dat je je vol en energiek voelt.

2. Eet bewust: let op de honger- en volheidssignalen van uw lichaam. Vermijd afleiding tijdens het eten.

3. Drink voldoende water: water is essentieel voor de spijsvertering, het energieniveau en de algehele gezondheid..

4. Ontneem jezelf niets: gun jezelf af en toe wat zoetigheid. Tekortkomingen kunnen later tot te veel eten leiden. Geniet van alles met mate!

5. Plan vooruit: bereid uw maaltijden of snacks van tevoren om te voorkomen dat u ongezonde keuzes maakt.

#GezondEten #GezondeLevensstijl #Voeding #Eetliefhebbers #GezondheidEnWelzijn #GezondeTips #SchoonEten #Gewichtsverlies #GezondeRecepten #VoedingsTips #DirectGezondheid #GezondEten #MindfulEten #GezondeReis #GezondheidsCoach

Natuurlijk kunnen we het nog ingewikkelder maken door een team samen te stellen met andere agenten die de lijst met websites doorzoeken op inhoud, een inhoudscontroleur en -beoordelaar, en nog iemand die een afbeelding voor het bericht maakt. Maar ik denk dat je het algemene idee krijgt van hoe je moet toevoegen tool naar mij Agent.

Een ander type gereedschap dat we kunnen toevoegen is: een gereedschap functie gereedschap. We kunnen een Python-functie gebruiken als hulpmiddel voor een groot taalmodel (LLM). Vergeet niet om typetips toe te voegen, zoals: video_id:str, zodat het model weet wat het als invoer voor de functie moet gebruiken. Anders kan er een foutmelding verschijnen.

Laten we even kort kijken hoe dit werkt.

Nu willen we dat onze agent een specifieke YouTube-video kan vinden en deze kan samenvatten. Om een dergelijke taak uit te voeren, maken we eenvoudigweg een functie die het videotranscript van YouTube downloadt en dit doorgeeft aan het model voor samenvatting.

# Imports
import os
from agno.agent import Agent
from agno.models.google import Gemini
from youtube_transcript_api import YouTubeTranscriptApi

# Get YT transcript
def get_yt_transcript(video_id:str) -> str:
      
    """
    Use this function to get the transcript from a YouTube video using the video id.

    Parameters
    ----------
    video_id : str
        The id of the YouTube video.
    Returns
    -------
    str
        The transcript of the video.
    """

    # Instantiate
    ytt_api = YouTubeTranscriptApi()
    # Fetch
    yt = ytt_api.fetch(video_id)
    # Return
    return ''.join([line.text for line in yt])

# Create agent
agent = Agent(
    model= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
                  description= "You are an assistant that summarizes YouTube videos.",
                  tools=[get_yt_transcript],
                  expected_output= "A summary of the video with the 5 main points and 2 questions for me to test my understanding.",
                  markdown=True,
                  show_tool_calls=True)

# Run agent
agent.print_response("""Summarize the text of the video with the id 'hrZSfMly_Ck' """,
                     markdown=True)

Dan krijg je een resultaat.

Agenten met redeneervermogen

Een andere geweldige optie die Agno biedt, is de mogelijkheid om agenten te creëren die een situatie kunnen analyseren voordat ze een vraag beantwoorden. Dit is het redeneergereedschap. verifiëren Soorten AI-agenten en hun toepassingen: een gedetailleerde uitleg.

We creëren een redenerende agent met behulp van het Qwen-qwq-32b-model van Alibaba. Houd er rekening mee dat het enige verschil hier, naast het model, is dat we de widget toevoegen. ReasoningTools(). Met deze tool kan de agent logisch nadenken voordat hij antwoorden geeft.

Eigendom betekent adding_instructions=True Door de agent gedetailleerde instructies te geven, wordt de betrouwbaarheid en nauwkeurigheid van het gebruik van de tool verbeterd. Het instellen van deze eigenschap resulteert in: False De agent dwingen om op zijn eigen redenering te vertrouwen, wat de kans op fouten kan vergroten. Hierdoor kunnen de mogelijkheden van het model onafhankelijk worden geëvalueerd.

# Imports
import os
from agno.agent import Agent
from agno.models.groq import Groq
from agno.tools.reasoning import ReasoningTools

# Create agent with reasoning
agent = Agent(
    model= Groq(id="qwen-qwq-32b",
                  api_key = os.environ.get("GROQ_API_KEY")),
                  description= "You are an experienced math teacher.",
                  tools=[ReasoningTools(add_instructions=True)],
                  show_tool_calls=True)

# Writing and saving a file
agent.print_response("""Explain the concept of sin and cosine in simple terms.""",
                     stream=True,
                     show_full_reasoning=True,
                     markdown=True)

Hieronder vindt u de uitkomsten.

kennisverstrekte agent

Deze tool is de eenvoudigste manier om een Recovery Augmented Generation (RAG)-systeem te creëren. Met deze functie kunt u de agent doorverwijzen naar een website of een lijst met websites. De inhoud wordt dan toegevoegd aan een vectordatabase. Daarna wordt de inhoud doorzoekbaar. Wanneer de agent daarom wordt gevraagd, kan hij de inhoud gebruiken als onderdeel van het antwoord. Deze technologie verbetert de nauwkeurigheid en betrouwbaarheid van AI-antwoorden.

In dit eenvoudige voorbeeld heb ik een pagina van mijn website toegevoegd en aan de agent gevraagd welke boeken daar vermeld stonden. Hierin wordt uitgelegd hoe de agent toegang kan krijgen tot de informatie en deze kan gebruiken.

# Imports
import os
from agno.agent import Agent
from agno.models.google import Gemini
from agno.knowledge.url import UrlKnowledge
from agno.vectordb.lancedb import LanceDb, SearchType
from agno.embedder.sentence_transformer import SentenceTransformerEmbedder

# Load webpage to the knowledge base
agent_knowledge = UrlKnowledge(
    urls=["https://gustavorsantos.me/?page_id=47"],
    vector_db=LanceDb(
        uri="tmp/lancedb",
        table_name="projects",
        search_type=SearchType.hybrid,
        # Use Sentence Transformer for embeddings
        embedder=SentenceTransformerEmbedder(),
    ),
)

# Create agent
agent = Agent(
    model=Gemini(id="gemini-2.0-flash", api_key=os.environ.get("GEMINI_API_KEY")),
    instructions=[
        "Use tables to display data.",
        "Search your knowledge before answering the question.",
        "Only inlcude the content from the agent_knowledge base table 'projects'",
        "Only include the output in your response. No other text.",
    ],
    knowledge=agent_knowledge,
    add_datetime_to_instructions=True,
    markdown=True,
)

if __name__ == "__main__":
    # Load the knowledge base, you can comment out after first run
    # Set recreate to True to recreate the knowledge base if needed
    agent.knowledge.load(recreate=False)
    agent.print_response(
        "What are the two books listed in the 'agent_knowledge'",
        stream=True,
        show_full_reasoning=True,
        stream_intermediate_steps=True,
    )

Geheugen-enabled agent

Het laatste type dat we in dit artikel bespreken, is de geheugengestuurde agent. Dit is een fundamenteel concept op het gebied van AI-agenten.

Dit type agent kan informatie over gebruikers uit eerdere interacties opslaan en ophalen. Zo kan de agent gebruikersvoorkeuren begrijpen en zijn reacties personaliseren. Dankzij dit geheugen is de agent effectiever in volgende interacties.

Laten we eens kijken naar het volgende voorbeeld, waarin ik de agent een aantal dingen vertel en op basis van die interactie om aanbevelingen vraag. Dit laat zien hoe een geheugen-enabled agent de gebruikerservaring kan verbeteren.

# imports
import os
from agno.agent import Agent
from agno.memory.v2.db.sqlite import SqliteMemoryDb
from agno.memory.v2.memory import Memory
from agno.models.google import Gemini
from rich.pretty import pprint

# User Name
user_id = "data_scientist"

# Creating a memory database
memory = Memory(
    db=SqliteMemoryDb(table_name="memory", 
                      db_file="tmp/memory.db"),
    model=Gemini(id="gemini-2.0-flash", 
                 api_key=os.environ.get("GEMINI_API_KEY"))
                 )

# Clear the memory before start
memory.clear()

# Create the agent
agent = Agent(
    model=Gemini(id="gemini-2.0-flash", api_key=os.environ.get("GEMINI_API_KEY")),
    user_id=user_id,
    memory=memory,
    # Enable the Agent to dynamically create and manage user memories
    enable_agentic_memory=True,
    add_datetime_to_instructions=True,
    markdown=True,
)

# Run the code
if __name__ == "__main__":
    agent.print_response("My name is Gustavo and I am a Data Scientist learning about AI Agents.")
    memories = memory.get_user_memories(user_id=user_id)
    print(f"Memories about {user_id}:")
    pprint(memories)
    agent.print_response("What topic should I study about?")
    agent.print_response("I write articles for Towards Data Science.")
    print(f"Memories about {user_id}:")
    pprint(memories)
    agent.print_response("Where should I post my next article?")

Hiermee sluiten we dit eerste artikel over Agenten voor kunstmatige intelligentie. Wij hopen dat dit een nuttig overzicht heeft gegeven van de verschillende typen AI-agenten.

1 meer antwoord

Dit artikel bevat veel informatie. We hebben de eerste stap op de leerladder van AI-agenten gezet. Ik weet dat het verwarrend kan zijn. Er is zoveel informatie beschikbaar dat het lastig kan zijn om te weten waar je moet beginnen en wat je moet leren.

Ik stel voor dat u dezelfde route neemt als ik. Kies stap voor stap een paar pakketten, zoals Agno en CrewAI, verdiep je erin en leer hoe je steeds complexere agents kunt maken. Deze geleidelijke aanpak is het meest geschikt om complexe AI-concepten te begrijpen.

In dit artikel beginnen we bij nul en leren we hoe je op een eenvoudige manier met een groot taalmodel (LLM) kunt interacteren. We gaan door tot het creëren van agenten met geheugen en zelfs het creëren van een eenvoudig retrieval augmentation (RAG)-systeem voor een AI-agent. Deze basisvaardigheden zijn essentieel om te begrijpen hoe AI-agenten werken.

Het is duidelijk dat je veel kunt doen met slechts één agent. Zie referentie [4] voor geavanceerde voorbeelden.

Met deze eenvoudige vaardigheden heeft u zeker een voorsprong op veel anderen, en er is al veel wat u kunt doen. Gebruik gewoon je creativiteit, waarom niet? Vraag een groot taalmodel om hulp bij het bouwen van iets geweldigs! Gebruik AI-hulpmiddelen om uw creativiteit te vergroten.

In het volgende artikel gaan we dieper in op AI-agenten en hun evaluatie. Blijf op de hoogte!