LlamaIndex

import asyncio
from llama_index.core.agent.workflow import FunctionAgent
from llama_index.llms.openai import OpenAI
from llama_index.tools.nimble import NimbleToolSpec

agent = FunctionAgent(
    tools=NimbleToolSpec().to_tool_list(),
    llm=OpenAI(model="gpt-4o-mini"),
    system_prompt="You are a research assistant. Use web search to answer with current facts.",
)

async def main():
    response = await agent.run("What has Nimble announced recently?")
    print(response)

asyncio.run(main())

<title>
URL: <source url>

<page content or snippet>

from llama_index.core import VectorStoreIndex
from llama_index.tools.nimble import NimbleToolSpec

# Fetch live web results as Documents
documents = NimbleToolSpec().search(
    "web data infrastructure trends",
    max_results=10,
)

# Index them, then query with citable sources
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()
response = query_engine.query("Summarize the key trends.")
print(response)

from llama_index.tools.nimble import NimbleAgentToolSpec

# timeout is raised past the 300 s default, because agent runs outlast it.
agent_tool = NimbleAgentToolSpec(timeout=1800)  # reads NIMBLE_API_KEY
doc = agent_tool.run(
    "What are the leading approaches to LLM guardrails, and who builds them?",
)

print(doc.text)                             # final answer + "Sources:" list
print(doc.metadata["confidence"])           # high / medium / low / pre_existing
print(doc.metadata["claims"])               # per-claim citations
print(doc.metadata["web_search_agent_id"])  # the agent the API ran this on

import asyncio
import os
from llama_index.core.agent.workflow import FunctionAgent
from llama_index.llms.openai import OpenAI
from llama_index.tools.nimble import NimbleAgentToolSpec

tool_spec = NimbleAgentToolSpec(
    agent_id=os.environ.get("NIMBLE_AGENT_ID"),
    timeout=1800,
)
agent = FunctionAgent(
    tools=tool_spec.to_tool_list(),
    llm=OpenAI(model="gpt-4o-mini"),
    system_prompt=(
        "You are a research assistant. For questions that need a researched, "
        "synthesized answer, call the Nimble research tool (it is slow but "
        "thorough) and relay its answer together with the source URLs it cites."
    ),
)

async def main():
    response = await agent.run(
        "Research: what do photography reviewers consider the best "
        "mirrorless cameras for travel, and why? Cite your sources."
    )
    print(response)

asyncio.run(main())

doc = agent_tool.run(
    "Find the founding year and headquarters for this company.",
    input_data={"company": "Acme", "domain": "acme.example"},
    output_schema={
        "type": "object",
        "properties": {"founded": {"type": "integer"}, "hq": {"type": "string"}},
    },
    sources={"prioritize": "regulatory filings", "avoid": "press releases"},
)

{
  "hq": "<headquarters city>",
  "founded": <year>
}

Sources:
- <source title> — <source url> (primary)
- <source title> — <source url> (secondary)

# Leading Approaches to LLM Guardrails

LLM guardrail approaches are organized around a multi-layered safety pipeline
spanning the model's lifecycle [1]:

## 1. Input-Level Defenses (Prompt Screening)
Pre-processing mechanisms block or modify disallowed prompts before they reach
the LLM, typically using classifiers, keyword/regex matching, or prompt-injection
detectors [2].

...

Sources:
- Survey on LLM Safety: Attacks, Defenses, Alignment, Metrics, and ... — https://link.springer.com/article/... (primary)
- A Survey on LLM Guardrails: Part 1, Methods, Best Practices and ... — https://blog.budecosystem.com/... (primary)
- Evaluating the Robustness of Large Language Model Safety Guardrails ... — https://arxiv.org/html/... (primary)

metadata["claims"][0] == {
    "callout": 1,
    "confidence": "high",
    "reasoning": "Backed by a primary source (academic)",
    "citations": [
        {
            "url": "https://link.springer.com/article/...",
            "title": "Survey on LLM Safety: Attacks, Defenses, Alignment, ...",
            "source_type": "primary",
            "source_category": "academic",
            "source_intent": "academic",
        },
    ],
}

from llama_index.tools.nimble import (
    NimbleAgentRunError,
    NimbleAgentTimeoutError,
    NimbleAgentToolSpec,
)

# x-high typically takes 15 to 30 minutes, so the deadline allows for that.
agent_tool = NimbleAgentToolSpec(effort="x-high", timeout=2400)

try:
    doc = agent_tool.run("Map the EU AI Act enforcement timeline.")
except NimbleAgentTimeoutError as error:
    # Not a failure. Persist the ids however your app stores state, then
    # fetch the run later. `save_run_for_later` here is your own function.
    save_run_for_later(error.run_id, error.agent_id)
except NimbleAgentRunError as error:
    print(error.status, error.run_id, error.agent_id)
    raise