Tutorial Composio: Platform Integrasi Tool untuk AI Agents

Composio adalah platform open-source yang memungkinkan AI agents terhubung dengan lebih dari 250+ tools dan aplikasi eksternal seperti GitHub, Slack, Gmail, Google Sheets, Jira, dan banyak lagi. Dengan Composio, Anda bisa membangun AI agents yang tidak hanya bisa berpikir, tetapi juga bertindak langsung di dunia nyata melalui integrasi API yang aman dan terkelola.

Dalam tutorial ini, kita akan mempelajari cara menggunakan Composio mulai dari instalasi, autentikasi, hingga membangun AI agent yang bisa berinteraksi dengan berbagai tools secara otomatis.

Mengapa Composio?

Membangun AI agent yang bisa berinteraksi dengan tools eksternal biasanya memerlukan banyak boilerplate code: mengelola OAuth tokens, menulis wrapper API, menangani rate limiting, dan memastikan keamanan. Composio menyelesaikan semua masalah ini dengan menyediakan:

• Managed Authentication: OAuth2, API Key, dan Basic Auth dikelola secara otomatis
• 250+ Pre-built Integrations: GitHub, Slack, Gmail, Notion, Jira, Linear, Google Drive, dan banyak lagi
• Framework Agnostic: Mendukung LangChain, CrewAI, AutoGen, LlamaIndex, OpenAI, dan framework lainnya
• Type-safe Actions: Setiap tool action memiliki schema yang jelas untuk input dan output
• Execution Environment: Mendukung eksekusi lokal, Docker, dan cloud

Instalasi

Instalasi Python SDK

pip install composio-core

Untuk integrasi dengan framework spesifik, install paket tambahan:

# Untuk OpenAI
pip install composio-openai

Untuk LangChain
pip install composio-langchain

Untuk CrewAI
pip install composio-crewai

Untuk Autogen
pip install composio-autogen

Untuk LlamaIndex
pip install composio-llamaindex

Instalasi CLI

Composio menyediakan CLI untuk mengelola koneksi dan tools:

pip install composio-core

Login ke Composio
composio login

Cek status
composio whoami

Setup API Key

Setelah login, Anda bisa mendapatkan API key dari dashboard Composio:

export COMPOSIOAPIKEY="your-api-key-here"

Atau simpan di file .env:

COMPOSIOAPIKEY=your-api-key-here

Basic Usage

Menghubungkan App

Langkah pertama adalah menghubungkan aplikasi yang ingin digunakan oleh agent. Composio mengelola proses OAuth secara otomatis:

from composio import ComposioToolSet, App, Action

Inisialisasi toolset
toolset = ComposioToolSet()

Memulai koneksi ke GitHub
Ini akan membuka browser untuk OAuth authorization
entity = toolset.getentity(id="default")

connectionrequest = entity.initiateconnection(

    appname=App.GITHUB
)

print(f"Buka URL ini untuk authorize: {connectionrequest.redirectUrl}")

print(f"Connection status: {connectionrequest.connectionStatus}")

Untuk CLI, proses koneksi lebih sederhana:

# Menambahkan koneksi GitHub
composio add github

Menambahkan koneksi Slack
composio add slack

Melihat daftar koneksi aktif
composio connections

Menggunakan Tools dengan OpenAI

Berikut contoh sederhana menggunakan Composio dengan OpenAI untuk membuat agent yang bisa berinteraksi dengan GitHub:

from composioopenai import ComposioToolSet, Action
from openai import OpenAI

Inisialisasi
client = OpenAI()
toolset = ComposioToolSet()

Ambil tools untuk GitHub
tools = toolset.gettools(actions=[
    Action.GITHUBCREATEISSUE,
    Action.GITHUBLISTREPOS,
    Action.GITHUBSTARREPO,
])

Buat request ke OpenAI dengan tools
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "system",
            "content": "Kamu adalah asisten yang bisa membantu mengelola GitHub repositories."
        },
        {
            "role": "user",
            "content": "Buatkan issue baru di repo 'myorg/myproject' dengan judul 'Fix login bug' dan deskripsi 'Login page returns 500 error when using SSO'"
        }
    ],
    tools=tools,
    toolchoice="auto"

)

Eksekusi tool calls
result = toolset.handletoolcalls(response)

print(result)

Menggunakan Tools dengan LangChain

from composiolangchain import ComposioToolSet, Action
from langchainopenai import ChatOpenAI

from langchain.agents import createopenaifunctionsagent, AgentExecutor
from langchaincore.prompts import ChatPromptTemplate


Setup
llm = ChatOpenAI(model="gpt-4o")
toolset = ComposioToolSet()

Ambil tools
tools = toolset.gettools(actions=[
    Action.GMAILSENDEMAIL,
    Action.GMAILLISTEMAILS,
    Action.GMAILREADEMAIL,
])

Buat prompt
prompt = ChatPromptTemplate.frommessages([

    ("system", "Kamu adalah asisten email yang membantu mengelola inbox."),
    ("human", "{input}"),
    ("placeholder", "{agentscratchpad}"),
])

Buat agent
agent = createopenaifunctionsagent(llm, tools, prompt)

agentexecutor = AgentExecutor(agent=agent, tools=tools, verbose=True)

Jalankan
result = agentexecutor.invoke({

    "input": "Tampilkan 5 email terbaru di inbox saya"
})
print(result["output"])

Advanced Usage

Custom Actions

Selain menggunakan actions bawaan, Anda bisa membuat custom action sendiri:

from composio import action

@action(toolname="customtool")
def calculateprojectcost(
    hours: float,
    hourlyrate: float,

    taxpercentage: float = 10.0
) -> dict:
    """
    Menghitung total biaya proyek berdasarkan jam kerja dan tarif.

    :param hours: Jumlah jam kerja
    :param hourlyrate: Tarif per jam dalam USD

    :param taxpercentage: Persentase pajak (default 10%)
    :return: Dictionary berisi subtotal, tax, dan total
    """
    subtotal = hours  hourlyrate

    tax = subtotal  (taxpercentage / 100)
    total = subtotal + tax

    return {
        "subtotal": subtotal,
        "tax": tax,
        "total": total,
        "currency": "USD"
    }

Triggers (Event-Driven Agents)

Composio mendukung triggers yang memungkinkan agent merespons event secara real-time:

from composio import ComposioToolSet, Action

toolset = ComposioToolSet()

Membuat listener untuk GitHub events
listener = toolset.createtriggerlistener()

@listener.callback(filters={"triggername": "GITHUBPULLREQUESTEVENT"})
def onpullrequest(event):
    """Dipanggil setiap ada PR baru di repository"""
    prdata = event.payload

    print(f"New PR: {prdata['title']}")
    print(f"Author: {prdata['user']['login']}")

    print(f"Repository: {prdata['repository']['fullname']}")


    # Agent bisa otomatis melakukan code review
    # atau mengirim notifikasi ke Slack
    return {"status": "processed"}

Mulai mendengarkan events
print("Listening for GitHub events...")
listener.listen()

Entity Management (Multi-User)

Untuk aplikasi yang melayani banyak pengguna, Composio menyediakan entity management:

from composio import ComposioToolSet

toolset = ComposioToolSet()

Setiap user memiliki entity sendiri
userentity = toolset.getentity(id="user-123")


Cek apakah user sudah terkoneksi ke GitHub
connections = userentity.getconnections()

githubconnected = any(
    conn.appName == "github" for conn in connections
)

if not githubconnected:

    # Inisiasi koneksi untuk user ini
    request = userentity.initiateconnection(appname="github")
    print(f"User perlu authorize: {request.redirectUrl}")
else:
    # User sudah terkoneksi, langsung gunakan tools
    tools = toolset.gettools(

        actions=["GITHUBLISTREPOS"],

        entityid="user-123"
    )

Filtering Tools

Ketika bekerja dengan banyak tools, Anda bisa memfilter berdasarkan use case:

from composio import ComposioToolSet, App

toolset = ComposioToolSet()

Filter tools berdasarkan app
githubtools = toolset.gettools(apps=[App.GITHUB])

Filter berdasarkan tags/use case
tools = toolset.gettools(

    apps=[App.GITHUB],
    tags=["issues", "pullrequests"]
)

Filter actions spesifik
tools = toolset.gettools(actions=[

    "GITHUBCREATEISSUE",

    "GITHUBLISTPULLREQUESTS",
    "GITHUBMERGEPULLREQUEST",

])

Integrasi dengan CrewAI

Composio sangat powerful ketika dikombinasikan dengan multi-agent frameworks seperti CrewAI:

from composiocrewai import ComposioToolSet, Action
from crewai import Agent, Task, Crew

toolset = ComposioToolSet()

Tools untuk project manager agent
pmtools = toolset.gettools(actions=[
    Action.GITHUBCREATEISSUE,
    Action.GITHUBLISTISSUES,
    Action.SLACKSENDMESSAGE,
])

Tools untuk developer agent
devtools = toolset.gettools(actions=[
    Action.GITHUBCREATEPULLREQUEST,

    Action.GITHUBLISTPULLREQUESTS,
    Action.GITHUBGETFILECONTENT,

])

Definisi agents
projectmanager = Agent(
    role="Project Manager",
    goal="Mengelola task dan koordinasi tim",
    backstory="PM berpengalaman yang efisien mengelola proyek software",
    tools=pmtools,

    verbose=True
)

developer = Agent(
    role="Software Developer",
    goal="Mengimplementasikan fitur dan fix bugs",
    backstory="Developer senior yang menulis kode berkualitas tinggi",
    tools=devtools,
    verbose=True
)

Definisi tasks
reviewtask = Task(

    description="Review semua open issues di repo 'myorg/myproject' dan buat ringkasan prioritas",
    agent=projectmanager,
    expectedoutput="Daftar issues terurut berdasarkan prioritas"

)

Jalankan crew
crew = Crew(
    agents=[projectmanager, developer],
    tasks=[reviewtask],

    verbose=True
)

result = crew.kickoff()
print(result)

Contoh Proyek: Automated PR Review Agent

Berikut contoh lengkap membangun agent yang otomatis melakukan code review pada setiap Pull Request baru:

from composioopenai import ComposioToolSet, Action
from openai import OpenAI

client = OpenAI()
toolset = ComposioToolSet()

def reviewpullrequest(repo: str, prnumber: int):

    """Review sebuah Pull Request secara otomatis"""

    # Ambil tools yang diperlukan
    tools = toolset.gettools(actions=[
        Action.GITHUBGETPULLREQUEST,

        Action.GITHUBLISTPULLREQUESTFILES,

        Action.GITHUBCREATEREVIEWCOMMENT,
    ])

    messages = [
        {
            "role": "system",
            "content": """Kamu adalah senior code reviewer. Tugasmu:
Baca diff dari Pull Request
Identifikasi potential bugs, security issues, dan code quality problems
Berikan review comment yang konstruktif
Fokus pada masalah penting, bukan formatting"""
        },
        {
            "role": "user",
            "content": f"Review PR #{prnumber} di repository {repo}. "

                       f"Ambil daftar files yang berubah, analisis perubahannya, "
                       f"dan berikan review comments."
        }
    ]

    # Loop untuk menangani multiple tool calls
    while True:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=tools,
            toolchoice="auto"
        )

        message = response.choices[0].message

        if message.toolcalls:

            # Eksekusi tool calls
            results = toolset.handletoolcalls(response)

            messages.append(message)
            for result in results:
                messages.append({
                    "role": "tool",
                    "toolcallid": result["toolcallid"],

                    "content": str(result["result"])
                })
        else:
            # Agent selesai review
            print("Review selesai:")
            print(message.content)
            break

Contoh penggunaan
reviewpullrequest("myorg/myproject", 42)

Daftar App yang Didukung

Berikut beberapa kategori app yang didukung Composio:

| Kategori | Apps |

|----------|------|

| Version Control | GitHub, GitLab, Bitbucket |

| Communication | Slack, Discord, Microsoft Teams |

| Email | Gmail, Outlook |

| Project Management | Jira, Linear, Asana, Trello, Notion |

| Cloud Storage | Google Drive, Dropbox, OneDrive |

| CRM | Salesforce, HubSpot |

| Database | Supabase, Airtable |

| Monitoring | Datadog, PagerDuty |

| CI/CD | GitHub Actions, CircleCI |

| Social | Twitter/X, LinkedIn |

Best Practices

1. Gunakan Actions Spesifik

Jangan load semua tools dari sebuah app. Pilih actions yang spesifik sesuai kebutuhan agent untuk mengurangi token usage dan meningkatkan akurasi:

# Kurang optimal - terlalu banyak tools
tools = toolset.gettools(apps=[App.GITHUB])  # 50+ actions

Lebih optimal - hanya yang diperlukan
tools = toolset.gettools(actions=[

    Action.GITHUBCREATEISSUE,

    Action.GITHUBLISTISSUES,

])

2. Kelola Koneksi dengan Aman

Selalu gunakan entity management untuk multi-user scenarios dan jangan hardcode credentials:

# Jangan lakukan ini
toolset = ComposioToolSet(apikey="hardcoded-key")

Gunakan environment variable
toolset = ComposioToolSet()  # Otomatis baca COMPOSIOAPIKEY

3. Handle Errors dengan Baik

from composio.exceptions import ComposioSDKError

try:
    result = toolset.executeaction(

        action=Action.GITHUBCREATEISSUE,

        params={
            "owner": "myorg",
            "repo": "myproject",
            "title": "Bug report",
            "body": "Description of the bug"
        }
    )
except ComposioSDKError as e:
    print(f"Composio error: {e}")
    # Handle gracefully

4. Gunakan Triggers untuk Event-Driven Architecture

Daripada polling, gunakan triggers untuk merespons events secara real-time. Ini lebih efisien dan responsif.

5. Testing dengan Sandbox

Saat development, gunakan Composio sandbox environment untuk testing tanpa mengubah data production:

# Gunakan environment sandbox untuk testing
toolset = ComposioToolSet(
    workspaceconfig={
        "type": "docker",
        "image": "composio/sandbox:latest"
    }
)

6. Monitoring dan Logging

Aktifkan logging untuk memantau penggunaan tools oleh agent:

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("composio")

Composio SDK akan log setiap action yang dieksekusi

Kesimpulan

Composio menyederhanakan proses membangun AI agents yang bisa berinteraksi dengan dunia nyata melalui integrasi tools yang terkelola. Dengan dukungan untuk 250+ aplikasi, managed authentication, dan kompatibilitas dengan berbagai AI framework, Composio menghilangkan kompleksitas boilerplate code sehingga Anda bisa fokus pada logika bisnis agent.

Poin-poin penting yang perlu diingat:

• Mulai dari yang sederhana: Pilih satu atau dua tools yang paling relevan dengan use case Anda
• Gunakan actions spesifik: Hindari loading semua tools sekaligus untuk efisiensi token
• Manfaatkan triggers: Untuk event-driven agents yang responsif dan efisien
• Entity management: Wajib untuk aplikasi multi-user production
• Keamanan: Selalu gunakan environment variables untuk API keys dan manfaatkan managed OAuth dari Composio

Dengan fondasi ini, Anda bisa mulai membangun AI agents yang benar-benar produktif dan bisa menyelesaikan tugas nyata secara otomatis.