LangChain

from typing import Any

from caesar_search import Caesar
from langchain_core.tools import tool

client = Caesar()  # reads CAESAR_API_KEY


@tool
def web_search(query: str, max_results: int = 5) -> dict[str, Any]:
    """Search the web with Caesar and return compact, citable results."""
    response = client.search(query, max_results=max_results, verbosity="compact")
    return {
        "search_id": response.search_id,
        "results": [
            {
                "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 web_fetch(target: str, query: str | None = None, max_chars: int | None = None) -> 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 = [web_search, web_fetch]

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

const caesar = new Caesar(); // reads CAESAR_API_KEY

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

    return {
      search_id: response.search_id,
      results: (response.results ?? []).map((result) => ({
        rank: result.rank,
        title: result.title,
        url: result.canonical_url,
        doc_id: result.doc_id,
        snippet: result.snippet,
      })),
    };
  },
  {
    name: "web_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,
    });

    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: "web_fetch",
    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)