Best Practices for Search

import asyncio
from tavily import AsyncTavilyClient

client = AsyncTavilyClient("tvly-YOUR_API_KEY")
queries = ["Tavily API pricing", "Tavily rate limits", "Tavily search features"]

async def main():
    responses = await asyncio.gather(
        *(client.search(q) for q in queries),
        return_exceptions=True,
    )
    for r in responses:
        print(f"Failed: {r}" if isinstance(r, Exception) else r)

asyncio.run(main())

const { tavily } = require("@tavily/core");
const client = tavily({ apiKey: "tvly-YOUR_API_KEY" });
const queries = ["Tavily API pricing", "Tavily rate limits", "Tavily search features"];

const responses = await Promise.allSettled(queries.map((q) => client.search(q)));
for (const r of responses) {
  console.log(r.status === "rejected" ? `Failed: ${r.reason}` : r.value);
}

import asyncio

sem = asyncio.Semaphore(20)  # in-flight cap; keep under your RPM

async def search_one(q, **kw):
    async with sem:
        for attempt in range(5):
            try:
                return {"query": q, "ok": True, "data": await client.search(q, **kw)}
            except Exception as e:
                if attempt == 4:
                    return {"query": q, "ok": False, "error": str(e)}
                await asyncio.sleep(2 ** attempt)  # exponential backoff

async def batch_search(queries, **kw):
    return await asyncio.gather(*(search_one(q, **kw) for q in queries))

results = asyncio.run(batch_search(queries, search_depth="advanced"))

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

// reuses `client` and `queries` from above
async function searchOne(query, options = {}) {
  for (let attempt = 0; attempt < 5; attempt++) {
    try {
      return { query, ok: true, data: await client.search(query, options) };
    } catch (e) {
      if (attempt === 4) return { query, ok: false, error: String(e) };
      await sleep(2 ** attempt * 1000); // exponential backoff
    }
  }
}

// process in waves of `concurrency` to cap in-flight requests
async function batchSearch(queries, options = {}, concurrency = 20) {
  const out = [];
  for (let i = 0; i < queries.length; i += concurrency) {
    const wave = queries.slice(i, i + concurrency);
    out.push(...(await Promise.all(wave.map((q) => searchOne(q, options)))));
  }
  return out;
}

const results = await batchSearch(queries, { searchDepth: "advanced" });

def dedupe(results):
    merged = {}
    for r in results:
        if not r["ok"]:
            continue
        for item in r["data"]["results"]:
            url = item["url"].split("?")[0].rstrip("/")  # canonicalize
            e = merged.setdefault(url, {"url": url, "score": 0, "chunks": []})
            e["score"] = max(e["score"], item.get("score", 0))
            for c in item.get("content", "").split("[...]"):
                if (c := c.strip()) and c not in e["chunks"]:
                    e["chunks"].append(c)
    return sorted(
        ({"url": e["url"], "score": e["score"], "content": " [...] ".join(e["chunks"])}
         for e in merged.values()),
        key=lambda x: x["score"], reverse=True,
    )

corpus = dedupe(results)  # dedupe the batch results from above

function dedupe(results) {
  const merged = new Map();
  for (const r of results) {
    if (!r.ok) continue;
    for (const item of r.data.results) {
      const url = item.url.split("?")[0].replace(/\/+$/, ""); // canonicalize
      const e = merged.get(url) || { url, score: 0, chunks: [] };
      e.score = Math.max(e.score, item.score ?? 0);
      for (const c of (item.content || "").split("[...]")) {
        const t = c.trim();
        if (t && !e.chunks.includes(t)) e.chunks.push(t);
      }
      merged.set(url, e);
    }
  }
  return [...merged.values()]
    .map((e) => ({ url: e.url, score: e.score, content: e.chunks.join(" [...] ") }))
    .sort((a, b) => b.score - a.score);
}

const corpus = dedupe(results); // dedupe the batch results from above