Agent Development

client.entries.create(
    entry_type="derived_insight",
    title="Weekly reading summary",
    content="This week you read 12 articles...",
    metadata={
        "source_agent": "librarian",
        "agent_version": "1.2.0",
        "generated_at": "2026-01-28T10:00:00Z",
        "source_entries": ["entry_123", "entry_456", "entry_789"]
    }
)

my-tagger-agent/
  pyproject.toml
  src/
    tagger/
      __init__.py
      agent.py
      classifier.py
      config.py
  tests/
    test_classifier.py
  Dockerfile
  .env.example

# config.py
import os
from pydantic_settings import BaseSettings

class Settings(BaseSettings):
    onelist_api_key: str
    onelist_base_url: str = "https://api.onelist.my"
    poll_interval_seconds: int = 60
    batch_size: int = 10
    openai_api_key: str  # For classification

    class Config:
        env_file = ".env"

settings = Settings()

# classifier.py
from openai import OpenAI
from .config import settings

openai_client = OpenAI(api_key=settings.openai_api_key)

TAXONOMY = [
    "work", "personal", "research", "reading",
    "project", "reference", "idea", "task"
]

def classify_content(title: str, content: str) -> list[str]:
    """Use LLM to classify content into taxonomy tags."""

    response = openai_client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "system",
                "content": f"""Classify the following content into one or more
categories from this list: {', '.join(TAXONOMY)}.
Return only the matching categories as a comma-separated list.
If none match well, return 'uncategorized'."""
            },
            {
                "role": "user",
                "content": f"Title: {title}\n\nContent: {content[:1000]}"
            }
        ],
        temperature=0
    )

    tags_str = response.choices[0].message.content.strip()
    return [f"category:{t.strip()}" for t in tags_str.split(",")]

# agent.py
import time
import logging
from onelist import Client
from .config import settings
from .classifier import classify_content

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

client = Client(
    api_key=settings.onelist_api_key,
    base_url=settings.onelist_base_url
)

def process_batch():
    """Process a batch of untagged entries."""

    # Find entries that need classification
    entries = client.entries.list(
        tags=["needs:classification"],
        limit=settings.batch_size
    )

    processed = 0

    for entry in entries:
        try:
            # Get the primary content
            content = entry.content or ""
            if not content and entry.representations:
                content = entry.representations[0].content

            # Classify the content
            suggested_tags = classify_content(entry.title, content)

            # Update the entry
            client.entries.update(
                entry_id=entry.id,
                tags_add=suggested_tags,
                tags_remove=["needs:classification"],
                metadata_merge={
                    "classified_by": "tagger-agent",
                    "classified_at": time.strftime("%Y-%m-%dT%H:%M:%SZ")
                }
            )

            logger.info(f"Tagged entry {entry.id}: {suggested_tags}")
            processed += 1

        except Exception as e:
            logger.error(f"Error processing {entry.id}: {e}")
            client.entries.update(
                entry_id=entry.id,
                tags_add=["error:classification-failed"]
            )

    return processed

def main():
    """Main agent loop."""
    logger.info("Tagger Agent starting...")
    logger.info(f"Polling every {settings.poll_interval_seconds}s")

    while True:
        try:
            processed = process_batch()
            if processed > 0:
                logger.info(f"Processed {processed} entries")
        except Exception as e:
            logger.error(f"Batch error: {e}")

        time.sleep(settings.poll_interval_seconds)

if __name__ == "__main__":
    main()

FROM python:3.12-slim

WORKDIR /app

COPY pyproject.toml .
RUN pip install .

COPY src/ src/

CMD ["python", "-m", "tagger.agent"]

# Build and run locally
docker build -t my-tagger-agent .
docker run -d \
  --name tagger-agent \
  -e ONELIST_API_KEY=$ONELIST_API_KEY \
  -e OPENAI_API_KEY=$OPENAI_API_KEY \
  my-tagger-agent

# Or deploy to a cloud service
# Railway, Fly.io, or any container platform