Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.quraite.ai/llms.txt

Use this file to discover all available pages before exploring further.

​
Overview

Quraite provides a built-in adapter for Smolagents. This adapter allows you to integrate Smolagents agents with Quraite and run evaluations on them. This adapter uses OpenInference instrumentation to capture the trajectory of the agent.

​
Prerequisites

  • Agent dependencies: smolagents[openai] package, OpenAI API key, and any tools you want to use.
  • Quraite dependencies: quraite[smolagents-oi] package.

​
Define Your Smolagents Agent

You create a normal Smolagents ToolCallingAgent first, exactly as you would in any Smolagents project. 
import datetime
import os
from zoneinfo import ZoneInfo

from smolagents import OpenAIServerModel, ToolCallingAgent, tool
from sqlalchemy import (
    Column,
    Float,
    Integer,
    MetaData,
    String,
    Table,
    create_engine,
    insert,
    text,
)


db_path = "receipts_db.sqlite"
if os.path.exists(db_path):
    os.remove(db_path)
engine = create_engine(f"sqlite:///{db_path}")
metadata_obj = MetaData()
table_name = "receipts"

receipts = Table(
    table_name,
    metadata_obj,
    Column("receipt_id", Integer, primary_key=True),
    Column("customer_name", String(32)),
    Column("price", Float),
    Column("tip", Float),
    Column("city", String(32)),
)

metadata_obj.create_all(engine)

rows = [
    {
        "receipt_id": 1,
        "customer_name": "Alan Payne",
        "price": 12.06,
        "tip": 1.20,
        "city": "New York",
    },
    # ... more rows ...
]

with engine.begin() as connection:
    for row in rows:
        connection.execute(insert(receipts).values(**row))


@tool
def sql_engine(query: str) -> str:
    """Execute SQL queries against the receipts table."""
    with engine.connect() as con:
        rows = con.execute(text(query))
        return "\n".join(str(row) for row in rows)


@tool
def current_time(city: str) -> str:
    """Return the current time for a known city."""
    mapping = {
        "new york": "America/New_York",
        "san francisco": "America/Los_Angeles",
        "london": "Europe/London",
    }
    tz_identifier = mapping.get(city.lower())
    if not tz_identifier:
        return f"Timezone for {city} not available."

    now = datetime.datetime.now(ZoneInfo(tz_identifier))
    return now.strftime("%Y-%m-%d %H:%M:%S %Z%z")


sql_agent = ToolCallingAgent(
    tools=[sql_engine, current_time],
    model=OpenAIServerModel("gpt-4o"),
)

​
Set up Tracing

Quraite provides a tracing setup helper. For Smolagents, pass the Framework.SMOLAGENTS enum: 
from quraite.tracing import Framework, setup_tracing


tracer_provider = setup_tracing([Framework.SMOLAGENTS])

​
Wrap the Smolagents Agent

Wrap the agent with the SmolagentsAdapter and pass the tracer_provider to it. 
from quraite.adapters import SmolagentsAdapter


adapter = SmolagentsAdapter(
    agent=sql_agent,
    agent_name="Smolagents SQL Agent",
    tracer_provider=tracer_provider,
)

​
Run the Agent

Once wrapped, you expose the adapter using Quraite’s run_agent helper. 
if __name__ == "__main__":
    from quraite import run_agent
    from dotenv import load_dotenv

    load_dotenv(override=True)

    run_agent(
        adapter,
        port=8080,
        host="0.0.0.0",
        tunnel="cloudflare",
    )

​
End-to-End Examples