LangChain

from typing import Any

from caesar_search import Caesar
from langchain_core.tools import tool

client = Caesar()  # reads CAESAR_API_KEY; anonymous works without a key


@tool
def caesar_search(query: str, max_results: int = 5) -> list[dict[str, Any]]:
    """Search the web with Caesar and return compact, citable results."""
    response = client.search(query, max_results=max_results, verbosity="compact")
    return [
        {
            "rank": result.rank,
            "title": result.title,
            "url": result.canonical_url,
            "doc_id": result.doc_id,
            "snippet": result.snippet,
        }
        for result in response.results or []
    ]


@tool
def caesar_read(target: str, query: str | None = None, max_chars: int = 12000) -> dict[str, Any]:
    """Read a Caesar doc_id or URL as clean markdown."""
    response = client.read(target, query=query, max_chars=max_chars)
    return {
        "doc_id": response.doc.doc_id,
        "url": response.doc.canonical_url,
        "title": response.doc.title,
        "content": response.content.text if response.content else "",
        "truncated": response.content.truncated if response.content else False,
    }


tools = [caesar_search, caesar_read]

import { tool } from "@langchain/core/tools";
import { z } from "zod";
import { Caesar } from "caesar-search";

const caesar = new Caesar(); // reads CAESAR_API_KEY; anonymous works without a key

export const caesarSearch = tool(
  async ({ query, max_results }) => {
    const response = await caesar.search(query, {
      maxResults: max_results ?? 5,
      verbosity: "compact",
    });

    return (response.results ?? []).map((result) => ({
      rank: result.rank,
      title: result.title,
      url: result.canonical_url,
      doc_id: result.doc_id,
      snippet: result.snippet,
    }));
  },
  {
    name: "caesar_search",
    description: "Search the web with Caesar and return compact, citable results.",
    schema: z.object({
      query: z.string(),
      max_results: z.number().int().min(1).max(50).optional(),
    }),
  },
);

export const caesarRead = tool(
  async ({ target, query, max_chars }) => {
    const response = await caesar.read(target, {
      query,
      maxChars: max_chars ?? 12000,
    });

    return {
      doc_id: response.doc?.doc_id,
      url: response.doc?.canonical_url,
      title: response.doc?.title,
      content: response.content?.text ?? "",
      truncated: response.content?.truncated ?? false,
    };
  },
  {
    name: "caesar_read",
    description: "Read a Caesar doc_id or URL as clean markdown.",
    schema: z.object({
      target: z.string(),
      query: z.string().optional(),
      max_chars: z.number().int().min(1).max(50000).optional(),
    }),
  },
);

export const tools = [caesarSearch, caesarRead];

client.feedback("result_helpful", search_id=search_id, doc_id=doc_id)