The Search API Built
for AI Agents

import requests

# Search with full content
response = requests.get("https://vybsly.ai/api/v1/search", params={
    "q": "how to build a RAG pipeline",
    "limit": 5,
    "mode": "agent",
    "guaranteed": "true"
})

for result in response.json()["results"]:
    print(result["title"])
    print(result["content"][:500])  # Full 30K chars available

// Search with full content
const res = await fetch(
  "https://vybsly.ai/api/v1/search?q=RAG+pipeline&limit=5&mode=agent"
);
const data = await res.json();

data.results.forEach(r => {
  console.log(r.title);
  console.log(r.content.slice(0, 500)); // Full 30K chars
});

# Search with full content
curl "https://vybsly.ai/api/v1/search?q=RAG+pipeline&limit=5&mode=agent"

# Extract any page
curl "https://vybsly.ai/api/v1/extract?url=https://docs.anthropic.com&format=markdown"

# Get directions
curl "https://vybsly.ai/api/v1/directions?from=NYC&to=LA"

# Inline: add encyclopedia results to any search
curl "https://vybsly.ai/api/v1/search?q=einstein&include=encyclopedia"

# Dedicated federated endpoint (cleaner for agents)
curl "https://vybsly.ai/api/v1/knowledge?q=quantum+physics&limit=10"

{
  "total_results": 10,
  "layers": {
    "vybsly": { "count": 7, "total_index": 24219426 },
    "vybpedia": { "count": 3, "total_found": 3279 }
  },
  "results": {
    "vybsly": [
      { "source": "vybsly", "url": "...", "content": "5000 chars...",
        "domain_score": 90, "page_type": "article" }
    ],
    "vybpedia": [
      { "source": "vybpedia", "title": "Quantum physics",
        "summary": "...", "categories": ["Quantum physics"],
        "page_type": "encyclopedia" }
    ]
  }
}

# Loose: prefer research domains, but allow edge results
curl "https://vybsly.ai/api/v1/search?q=mRNA+vaccines&research=true"

# Strict: ONLY peer-reviewed research domains (arxiv, nature, pubmed, NEJM, Lancet, ...)
curl "https://vybsly.ai/api/v1/search?q=mRNA+vaccines&research=true&strict=true"

# Strict + fallback: when too few strict results, auto-fill with relaxed (clearly tagged)
curl "https://vybsly.ai/api/v1/search?q=obscure+topic&research=true&strict=true&strict_fallback=relaxed"

{
  "_meta": {
    "index_size": 23576356,
    "index_size_formatted": "24.22M pages",
    "version": "1.2",
    "strict_mode": true,
    "strict_filters_applied": ["research"],
    "strict_insufficient": false,
    "strict_fallback_used": false,
    "strict_pass_count": 7
  },
  "results": [{
    "url": "https://www.nature.com/...",
    "domain": "nature.com",
    "domain_score": 90,
    "strict_pass": true,
    "confidence": 0.95
  }]
}

# Python — full RAG pipeline in 8 lines
import requests

q = "latest CRISPR breakthroughs in 2026"
hits = requests.get("https://vybsly.ai/api/v1/search",
    params={"q": q, "research": "true", "strict": "true", "limit": 5}).json()["results"]

# Each result already has 30K chars of content — no extra extract needed
context = "\n\n".join([f"## {r['title']}\n{r['content'][:5000]}" for r in hits])

# Hand to your local LLM with the context
prompt = f"Answer using only these sources:\n{context}\n\nQuestion: {q}"

curl -X POST "https://vybsly.ai/api/v1/ask" \
  -H "Content-Type: application/json" \
  -d '{"question": "How does mRNA vaccine work?", "max_sources": 5}'

# Returns: { answer: "...", sources: [{ title, url }, ...] }

# Pull OpenAI/LangChain compatible tool list
curl "https://vybsly.ai/api/v1/tools"

# Returns 15+ tools ready for function-calling agents:
# search, extract, stocks, odds, weather, geocode, directions, ...

# Install globally
npm install -g vybsly-mcp

# Or run without installing (recommended for Claude Desktop)
npx vybsly-mcp

{
  "mcpServers": {
    "vybsly": {
      "command": "npx",
      "args": ["-y", "vybsly-mcp"],
      "env": { "VYBSLY_API_KEY": "your_api_key_here" }
    }
  }
}

from langchain.tools import Tool
import requests

def vybsly_search(query: str) -> str:
    r = requests.get("https://vybsly.ai/api/v1/search",
        params={"q": query, "limit": 5, "mode": "agent"}).json()
    return "\n\n".join([f"[{r['title']}]({r['url']})\n{r['content'][:3000]}"
                        for r in r["results"]])

vybsly_tool = Tool(
    name="VybslySearch",
    func=vybsly_search,
    description="Full-content web search across 24.22M pages. Returns up to 30K chars per result."
)

# Add to any LangChain agent
from langchain.agents import initialize_agent, AgentType
agent = initialize_agent([vybsly_tool], llm, agent=AgentType.OPENAI_FUNCTIONS)
result = agent.run("What are the latest CRISPR breakthroughs?")

from langchain.tools import Tool
import requests

def vybsly_knowledge(query: str) -> str:
    """Federated search: 24M web pages + 7.5M encyclopedia articles in one call.

    Returns both layers so the LLM sees messy web context AND structured
    encyclopedia articles (with categories, summaries). Better grounding
    than web-only search for research, definitions, and factual queries.
    """
    r = requests.get("https://vybsly.ai/api/v1/knowledge",
        params={"q": query, "limit": 10}).json()

    parts = []
    # Encyclopedia first (structured, authoritative)
    for r in r.get("results", {}).get("vybpedia", []):
        parts.append(f"[ENCYCLOPEDIA] {r['title']}\n"
                     f"Categories: {', '.join(r.get('categories', []))}\n"
                     f"{r.get('summary', '')}\n")
    # Then web (long-form, messy but full-content)
    for r in r.get("results", {}).get("vybsly", []):
        parts.append(f"[WEB] {r['title']} ({r.get('domain','?')})\n"
                     f"{r.get('content', '')[:2000]}\n")
    return "\n---\n".join(parts)

knowledge_tool = Tool(
    name="VybslyKnowledge",
    func=vybsly_knowledge,
    description="Hybrid web + encyclopedia search. Use for factual/research queries needing both structured authority (encyclopedia) and breadth (web). 24M web + 7.5M encyclopedia articles."
)

# Use as a standalone tool OR alongside VybslySearch / VybslyResearch
agent = initialize_agent([knowledge_tool], llm, agent=AgentType.OPENAI_FUNCTIONS)
result = agent.run("What is Einstein's general relativity and who verified it?")

def vybsly_research(query: str) -> str:
    """Search ONLY peer-reviewed research (arxiv, nature, pubmed, NEJM, Lancet)."""
    r = requests.get("https://vybsly.ai/api/v1/search",
        params={"q": query, "research": "true", "strict": "true",
                "strict_fallback": "relaxed", "limit": 5}).json()
    return "\n\n".join([f"[{r['domain']}] {r['title']}\n{r['content'][:3000]}"
                        for r in r["results"]])

research_tool = Tool(name="VybslyResearch", func=vybsly_research,
    description="Peer-reviewed research search. Use for medical, scientific, or technical queries needing authoritative sources.")

from llama_index.core.tools import FunctionTool
from llama_index.core.agent import ReActAgent
import requests

def vybsly_search(query: str, research_only: bool = False) -> dict:
    """Full-content web search. Set research_only=True for peer-reviewed sources."""
    params = {"q": query, "limit": 5, "mode": "agent"}
    if research_only:
        params.update({"research": "true", "strict": "true"})
    return requests.get("https://vybsly.ai/api/v1/search", params=params).json()

vybsly_tool = FunctionTool.from_defaults(fn=vybsly_search)
agent = ReActAgent.from_tools([vybsly_tool], llm=llm, verbose=True)
response = agent.chat("Compare the latest LLM benchmarks")

# Vapi Server Tool — give your voice agent live web knowledge
# 1. Create a server endpoint that Vapi calls when the agent needs info

from fastapi import FastAPI, Request
import requests

app = FastAPI()

@app.post("/vapi-tool")
async def vapi_search_tool(req: Request):
    body = await req.json()
    query = body["message"]["toolCalls"][0]["function"]["arguments"]["query"]

    # Search Vybsly — get clean markdown, not HTML noise
    results = requests.get("https://vybsly.ai/api/v1/search", params={
        "q": query, "limit": 3, "guaranteed": "true"
    }, headers={"X-API-Key": "YOUR_KEY"}).json()

    # Format top result as spoken context for the voice agent
    top = results["results"][0]
    context = f"{top['title']}: {top['content'][:2000]}"

    return {"results": [{
        "toolCallId": body["message"]["toolCalls"][0]["id"],
        "result": context
    }]}

# Trust-aware agent search — only use high-authority sources

results = vybsly.search("kubernetes pod security", limit=10)

# Filter: only trust canonical docs (domain_score >= 80)
trusted = [r for r in results if r.get("domain_score", 0) >= 80]

# Filter: only official developer docs
official = [r for r in results if r.get("is_agent_docs") == True]

# Skip junk: no tag pages, no archive pages
clean = [r for r in results if r.get("page_type") not in ("tag", "archive")]

# Strict mode: use domain allowlists for maximum reliability
strict = vybsly.search("CRISPR safety", research=True, strict=True)
# Check _meta.strict_pass on each result to verify it passed