Tutorial Phidata (Agno): Framework AI Agent yang Simpel dan Powerful

Membangun AI agent yang cerdas dan otonom kini semakin mudah dengan hadirnya Phidata (sekarang dikenal sebagai Agno). Framework ini menawarkan pendekatan yang lebih sederhana dibandingkan CrewAI atau LangGraph, namun tetap powerful untuk berbagai use case mulai dari chatbot sederhana hingga multi-agent system yang kompleks.

Dalam tutorial ini, kita akan mempelajari cara membangun AI agent menggunakan Phidata/Agno dari nol hingga membuat research agent yang dapat mencari informasi di web dan menulis laporan secara otomatis.

Apa itu Phidata/Agno?

Phidata adalah framework open-source untuk membangun AI agent dengan Python. Framework ini dirancang dengan filosofi simplicity-first, di mana Anda bisa membuat agent yang functional hanya dengan beberapa baris kode. Phidata baru-baru ini melakukan rebranding menjadi Agno, namun konsep dan API-nya tetap konsisten.

Keunggulan utama Phidata/Agno:

• Mudah dipelajari: API yang intuitif dan dokumentasi yang lengkap
• Built-in tools: Web search, file operations, SQL, dan banyak lagi
• Knowledge bases: Integrasi dengan vector database untuk RAG
• Memory dan storage: Agent yang bisa mengingat konteks percakapan
• Multi-agent teams: Orkestrasi beberapa agent sekaligus
• Structured outputs: Output terstruktur dengan Pydantic models
• Streaming: Dukungan streaming response secara real-time

Instalasi dan Setup

Instalasi Package

# Instalasi Phidata/Agno
pip install agno

Atau jika menggunakan nama lama
pip install phidata

Dependensi tambahan untuk tools
pip install openai duckduckgo-search sqlalchemy pgvector

Konfigurasi API Key

# Set environment variable untuk OpenAI
export OPENAIAPIKEY="sk-your-api-key-here"

Atau gunakan file .env
echo 'OPENAIAPIKEY=sk-your-api-key-here' > .env

# Atau set langsung di Python
import os
os.environ["OPENAIAPIKEY"] = "sk-your-api-key-here"

Membuat Agent Pertama

Agent Sederhana

from agno.agent import Agent
from agno.models.openai import OpenAIChat

Buat agent sederhana
agent = Agent(
    model=OpenAIChat(id="gpt-4o-mini"),
    description="Kamu adalah asisten yang helpful dan ramah.",
    instructions=[
        "Jawab dalam bahasa Indonesia",
        "Berikan jawaban yang jelas dan terstruktur"
    ],
    markdown=True
)

Jalankan agent
agent.printresponse("Jelaskan apa itu machine learning dalam 3 paragraf")

agent = Agent(
    model=OpenAIChat(id="gpt-4o"),
    description="Kamu adalah data scientist senior dengan 10 tahun pengalaman.",
    instructions=[
        "Berikan jawaban yang teknis namun mudah dipahami",
        "Sertakan contoh kode Python jika relevan",
        "Gunakan analogi untuk menjelaskan konsep kompleks",
        "Selalu rekomendasikan best practices"
    ],
    markdown=True,
    showtoolcalls=True

)

response = agent.run("Bagaimana cara menangani imbalanced dataset?")
print(response.content)

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools

Agent dengan kemampuan web search
webagent = Agent(
    model=OpenAIChat(id="gpt-4o-mini"),
    tools=[DuckDuckGoTools()],
    description="Kamu adalah research assistant yang bisa mencari informasi di internet.",
    instructions=[
        "Selalu cari informasi terbaru sebelum menjawab",
        "Sertakan sumber informasi",
        "Berikan ringkasan yang terstruktur"
    ],
    showtoolcalls=True,
    markdown=True
)

webagent.printresponse("Apa perkembangan terbaru AI di Indonesia tahun 2026?")

File Operations Tool

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.file import FileTools

Agent yang bisa membaca dan menulis file
fileagent = Agent(

    model=OpenAIChat(id="gpt-4o-mini"),
    tools=[FileTools(basedir="./output")],
    description="Kamu adalah asisten yang bisa mengelola file.",
    instructions=[
        "Baca file yang diminta dan berikan ringkasannya",
        "Tulis hasil analisis ke file baru jika diminta"
    ],
    showtoolcalls=True
)

fileagent.printresponse("Buat file report.txt berisi ringkasan tentang tren AI 2026")

SQL Tool

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.sql import SQLTools

Agent yang bisa query database
sqlagent = Agent(

    model=OpenAIChat(id="gpt-4o"),
    tools=[SQLTools(
        dburl="postgresql://user:password@localhost:5432/mydb"
    )],
    description="Kamu adalah database analyst.",
    instructions=[
        "Analisis pertanyaan user dan buat SQL query yang tepat",
        "Jelaskan hasil query dalam bahasa yang mudah dipahami",
        "Jangan pernah menjalankan DELETE atau DROP tanpa konfirmasi"
    ],
    showtoolcalls=True,
    markdown=True
)

sqlagent.printresponse("Berapa total penjualan bulan lalu per kategori produk?")

Custom Tools

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools import tool

Definisikan custom tool
@tool
def calculatebmi(weightkg: float, heightm: float) -> str:

    """Menghitung Body Mass Index (BMI) berdasarkan berat dan tinggi badan.

    Args:
        weightkg: Berat badan dalam kilogram
        heightm: Tinggi badan dalam meter


    Returns:
        Hasil perhitungan BMI dan kategorinya
    """
    bmi = weightkg / (heightm * 2)


    if bmi < 18.5:
        category = "Underweight"
    elif bmi < 25:
        category = "Normal"
    elif bmi < 30:
        category = "Overweight"
    else:
        category = "Obese"

    return f"BMI: {bmi:.1f} - Kategori: {category}"

@tool
def getweather(city: str) -> str:
    """Mendapatkan informasi cuaca untuk kota tertentu.

    Args:
        city: Nama kota

    Returns:
        Informasi cuaca
    """
    # Simulasi data cuaca
    return f"Cuaca di {city}: Cerah, 28°C, Kelembaban 65%"

Agent dengan custom tools
healthagent = Agent(

    model=OpenAIChat(id="gpt-4o-mini"),
    tools=[calculatebmi, getweather],

    description="Kamu adalah asisten kesehatan.",
    showtoolcalls=True

)

healthagent.printresponse("Hitung BMI saya: berat 70kg, tinggi 1.75m")

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.knowledge.pdf import PDFKnowledgeBase
from agno.vectordb.pgvector import PgVector

Buat knowledge base dari PDF
knowledgebase = PDFKnowledgeBase(
    path="./documents",
    vectordb=PgVector(

        tablename="pdfdocuments",

        dburl="postgresql+psycopg://user:pass@localhost:5432/ai"
    )
)

Load documents ke vector database (jalankan sekali)
knowledgebase.load()


Agent dengan knowledge base
docagent = Agent(
    model=OpenAIChat(id="gpt-4o"),
    knowledge=knowledgebase,

    description="Kamu adalah asisten yang menjawab berdasarkan dokumen perusahaan.",
    instructions=[
        "Jawab HANYA berdasarkan informasi dari knowledge base",
        "Jika informasi tidak ditemukan, katakan dengan jujur",
        "Sertakan referensi dokumen sumber"
    ],
    searchknowledge=True,
    markdown=True
)

docagent.printresponse("Apa kebijakan cuti karyawan?")

from agno.knowledge.website import WebsiteKnowledgeBase
from agno.vectordb.pgvector import PgVector

webkb = WebsiteKnowledgeBase(

    urls=["https://docs.python.org/3/tutorial/"],
    maxdepth=2,
    vectordb=PgVector(

        tablename="pythondocs",

        dburl="postgresql+psycopg://user:pass@localhost:5432/ai"
    )
)
webkb.load()

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.memory.db.postgres import PgMemory
from agno.storage.postgres import PostgresStorage

Agent dengan memory dan storage
persistentagent = Agent(
    model=OpenAIChat(id="gpt-4o-mini"),
    # Memory untuk mengingat percakapan
    memory=PgMemory(
        tablename="agentmemory",
        dburl="postgresql+psycopg://user:pass@localhost:5432/ai"

    ),
    # Storage untuk menyimpan session
    storage=PostgresStorage(
        tablename="agentsessions",

        dburl="postgresql+psycopg://user:pass@localhost:5432/ai"
    ),
    description="Kamu adalah asisten personal yang mengingat percakapan sebelumnya.",
    instructions=[
        "Ingat preferensi dan konteks user dari percakapan sebelumnya",
        "Personalisasi jawaban berdasarkan riwayat interaksi"
    ],
    # Aktifkan fitur memory
    addhistorytomessages=True,

    numhistoryresponses=5,

    createusermemories=True,

    markdown=True
)

Session 1
persistentagent.printresponse(

    "Nama saya Budi, saya seorang data engineer di Jakarta",
    sessionid="user-budi-001"
)

Session 2 - agent akan ingat konteks sebelumnya
persistentagent.printresponse(
    "Rekomendasikan buku untuk profesi saya",
    sessionid="user-budi-001"

)

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.tools.file import FileTools

Agent Researcher
researcher = Agent(
    name="Researcher",
    model=OpenAIChat(id="gpt-4o"),
    tools=[DuckDuckGoTools()],
    description="Kamu adalah peneliti yang ahli mencari dan menganalisis informasi.",
    instructions=[
        "Cari informasi yang relevan dan terkini",
        "Verifikasi fakta dari multiple sources",
        "Berikan data dan statistik yang akurat"
    ]
)

Agent Writer
writer = Agent(
    name="Writer",
    model=OpenAIChat(id="gpt-4o"),
    tools=[FileTools(basedir="./output")],
    description="Kamu adalah penulis konten profesional.",
    instructions=[
        "Tulis konten yang engaging dan informatif",
        "Gunakan struktur yang jelas dengan heading dan bullet points",
        "Sesuaikan gaya penulisan dengan target audience"
    ]
)

Team Leader yang mengkoordinasi
teamleader = Agent(

    name="Team Leader",
    model=OpenAIChat(id="gpt-4o"),
    team=[researcher, writer],
    description="Kamu adalah project manager yang mengkoordinasi tim research dan writing.",
    instructions=[
        "Delegasikan tugas research ke Researcher",
        "Delegasikan tugas penulisan ke Writer",
        "Pastikan output akhir berkualitas tinggi",
        "Review dan gabungkan hasil dari semua agent"
    ],
    showtoolcalls=True,

    markdown=True
)

teamleader.printresponse(

    "Buat artikel tentang perkembangan AI generatif di Asia Tenggara 2026"
)

from pydantic import BaseModel, Field
from typing import List, Optional
from agno.agent import Agent
from agno.models.openai import OpenAIChat

Definisikan output schema
class MovieReview(BaseModel):
    title: str = Field(description="Judul film")
    genre: List[str] = Field(description="Genre film")
    rating: float = Field(description="Rating 1-10")
    summary: str = Field(description="Ringkasan review")
    pros: List[str] = Field(description="Kelebihan film")
    cons: List[str] = Field(description="Kekurangan film")
    recommendation: bool = Field(description="Apakah direkomendasikan")

Agent dengan structured output
reviewagent = Agent(
    model=OpenAIChat(id="gpt-4o-mini"),
    description="Kamu adalah kritikus film profesional.",
    responsemodel=MovieReview

)

Response akan berupa MovieReview object
response = reviewagent.run("Review film The Matrix")
review = response.content

print(f"Film: {review.title}")
print(f"Rating: {review.rating}/10")
print(f"Direkomendasikan: {'Ya' if review.recommendation else 'Tidak'}")

class CompanyInfo(BaseModel):
    name: str
    industry: str
    foundedyear: Optional[int]

    headquarters: Optional[str]
    products: List[str]
    employeecount: Optional[str]

extractagent = Agent(

    model=OpenAIChat(id="gpt-4o-mini"),
    description="Kamu mengekstrak informasi perusahaan dari teks.",
    responsemodel=CompanyInfo
)

text = """
Gojek adalah perusahaan teknologi asal Indonesia yang didirikan tahun 2010 
di Jakarta. Perusahaan ini menyediakan layanan ride-hailing, food delivery 
(GoFood), pembayaran digital (GoPay), dan logistik. Gojek memiliki lebih 
dari 5000 karyawan.
"""

response = extractagent.run(f"Ekstrak informasi perusahaan: {text}")

info = response.content
print(f"Perusahaan: {info.name}")
print(f"Produk: {', '.join(info.products)}")

from agno.agent import Agent
from agno.models.openai import OpenAIChat

agent = Agent(
    model=OpenAIChat(id="gpt-4o-mini"),
    description="Kamu adalah storyteller yang kreatif.",
    markdown=True
)

Streaming response
for chunk in agent.run("Ceritakan kisah tentang robot yang belajar memasak", stream=True):
    print(chunk.content, end="", flush=True)

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools

agent = Agent(
    model=OpenAIChat(id="gpt-4o-mini"),
    tools=[DuckDuckGoTools()],
    showtoolcalls=True,

    markdown=True
)

Stream response termasuk tool calls
responsestream = agent.run(
    "Cari berita terbaru tentang startup AI di Indonesia",
    stream=True
)

for chunk in responsestream:

    if chunk.content:
        print(chunk.content, end="", flush=True)
    if chunk.toolcalls:
        for toolcall in chunk.toolcalls:
            print(f"\n[Calling tool: {toolcall.function.name}]")

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.tools.file import FileTools
from pydantic import BaseModel, Field
from typing import List
from datetime import datetime

Schema untuk laporan penelitian
class ResearchSection(BaseModel):
    heading: str = Field(description="Judul seksi")
    content: str = Field(description="Isi konten seksi")
    sources: List[str] = Field(description="Sumber referensi")

class ResearchReport(BaseModel):
    title: str = Field(description="Judul laporan")
    executivesummary: str = Field(description="Ringkasan eksekutif")
    sections: List[ResearchSection] = Field(description="Seksi-seksi laporan")
    conclusion: str = Field(description="Kesimpulan")
    recommendations: List[str] = Field(description="Rekomendasi")

Agent untuk research
researchagent = Agent(

    name="WebResearcher",
    model=OpenAIChat(id="gpt-4o"),
    tools=[DuckDuckGoTools()],
    description="Kamu adalah peneliti yang ahli dalam mencari dan mengumpulkan informasi.",
    instructions=[
        "Cari informasi dari berbagai sumber",
        "Fokus pada data terbaru dan terpercaya",
        "Catat semua sumber referensi",
        "Berikan fakta dan statistik yang relevan"
    ],
    showtoolcalls=True

)

Agent untuk menulis laporan
writeragent = Agent(
    name="ReportWriter",
    model=OpenAIChat(id="gpt-4o"),
    tools=[FileTools(basedir="./reports")],

    description="Kamu adalah penulis laporan profesional.",
    instructions=[
        "Tulis laporan yang terstruktur dan komprehensif",
        "Gunakan bahasa yang formal namun mudah dipahami",
        "Sertakan data pendukung dan referensi",
        "Buat rekomendasi yang actionable"
    ]
)

Koordinator tim
researchteam = Agent(
    name="ResearchCoordinator",
    model=OpenAIChat(id="gpt-4o"),
    team=[researchagent, writeragent],
    description="Kamu mengkoordinasi proses penelitian dan penulisan laporan.",
    instructions=[
        "1. Minta WebResearcher mencari informasi tentang topik",
        "2. Analisis dan sintesis hasil pencarian",
        "3. Minta ReportWriter menulis laporan lengkap",
        "4. Review dan pastikan kualitas laporan"
    ],
    responsemodel=ResearchReport,

    showtoolcalls=True,

    markdown=True
)

Jalankan research
topic = "Implementasi AI dalam sektor perbankan di Indonesia 2026"
response = researchteam.run(f"Buat laporan penelitian tentang: {topic}")

report = response.content
print(f"\n{'='60}")
print(f"LAPORAN: {report.title}")
print(f"{'='*60}")
print(f"\nRingkasan Eksekutif:\n{report.executivesummary}")


for section in report.sections:
    print(f"\n## {section.heading}")
    print(section.content)
    print(f"Sumber: {', '.join(section.sources)}")

print(f"\nKesimpulan:\n{report.conclusion}")
print(f"\nRekomendasi:")
for i, rec in enumerate(report.recommendations, 1):
    print(f"  {i}. {rec}")

# Buat direktori proyek
mkdir research-agent && cd research-agent

Setup virtual environment
python -m venv venv
source venv/bin/activate

Install dependencies
pip install agno openai duckduckgo-search

Set API key
export OPENAIAPIKEY="your-key-here"


Jalankan
python researchagent.py

Tips dan Best Practices

try:
    response = agent.run("query here")
except Exception as e:
    print(f"Error: {e}")
    # Implement retry logic atau fallback

Kesimpulan

Phidata/Agno adalah framework yang sangat cocok untuk membangun AI agent dengan cepat dan efisien. Dibandingkan dengan framework lain seperti CrewAI atau LangGraph, Phidata menawarkan learning curve yang lebih rendah tanpa mengorbankan fleksibilitas. Dengan fitur-fitur seperti built-in tools, knowledge bases, memory, dan multi-agent teams, Anda bisa membangun sistem AI yang kompleks dengan kode yang bersih dan mudah dipelihara.

Mulailah dengan agent sederhana, tambahkan tools sesuai kebutuhan, dan secara bertahap tingkatkan kompleksitas sistem Anda. Selamat mencoba!