Skip to content

PerplexitySearchAPITool

autogen.beta.tools.search.perplexity_search_api.PerplexitySearchAPITool #

PerplexitySearchAPITool(api_key=None, max_results=None, max_tokens_per_page=None, search_domain_filter=None, search_recency_filter=None, search_after_date_filter=None, search_before_date_filter=None, client=None, name='perplexity_search_api', *, description="Search the web with the Perplexity Search API. Returns ranked results with title, URL, snippet, and date. Supports domain allow/deny filters (prefix a domain with '-' to exclude it) and recency / date-range filters.", middleware=())

Bases: Tool

Search the web using the Perplexity Search API.

This tool calls Perplexity's dedicated Search endpoint (client.search.create), which returns a ranked list of web results with title, URL, snippet, and date. Unlike chat-completion-based search, this does not generate an LLM answer — it returns raw search results, which keeps token usage minimal and lets the calling agent decide how to consume them.

See https://docs.perplexity.ai/docs/search/quickstart for endpoint docs.

Source code in autogen/beta/tools/search/perplexity_search_api.py 
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
def __init__(
    self,
    api_key: str | None = None,
    max_results: int | Variable | None = None,
    max_tokens_per_page: int | Variable | None = None,
    search_domain_filter: Sequence[str] | Variable | None = None,
    search_recency_filter: RecencyFilter | Variable | None = None,
    search_after_date_filter: str | Variable | None = None,
    search_before_date_filter: str | Variable | None = None,
    client: Perplexity | None = None,
    name: str = "perplexity_search_api",
    *,
    description: str = (
        "Search the web with the Perplexity Search API. Returns ranked results "
        "with title, URL, snippet, and date. Supports domain allow/deny filters "
        "(prefix a domain with '-' to exclude it) and recency / date-range filters."
    ),
    middleware: Iterable[ToolMiddleware] = (),
) -> None:
    _client = client if client is not None else Perplexity(api_key=api_key)

    @tool(
        name=name,
        description=description,
        middleware=middleware,
    )
    def perplexity_search_api(
        query: Annotated[str, Field(description="The search query string.")],
        ctx: Context,
    ) -> ToolResult:
        """Run a Perplexity Search API call and return structured results."""
        params: dict[str, Any] = {
            "max_results": resolve_variable(max_results, ctx, param_name="max_results"),
            "max_tokens_per_page": resolve_variable(max_tokens_per_page, ctx, param_name="max_tokens_per_page"),
            "search_domain_filter": resolve_variable(search_domain_filter, ctx, param_name="search_domain_filter"),
            "search_recency_filter": resolve_variable(
                search_recency_filter, ctx, param_name="search_recency_filter"
            ),
            "search_after_date_filter": resolve_variable(
                search_after_date_filter, ctx, param_name="search_after_date_filter"
            ),
            "search_before_date_filter": resolve_variable(
                search_before_date_filter, ctx, param_name="search_before_date_filter"
            ),
        }
        kwargs = {k: v for k, v in params.items() if v is not None}

        raw = _client.search.create(query=query, **kwargs)

        raw_results: list[Any] = list(getattr(raw, "results", None) or [])
        results = [
            SearchResult(
                title=getattr(r, "title", "") or "",
                url=getattr(r, "url", "") or "",
                snippet=getattr(r, "snippet", None),
                date=getattr(r, "date", None),
            )
            for r in raw_results
        ]

        return ToolResult(SearchResponse(query=query, results=results))

    self._tool = perplexity_search_api
    self.name = name

name instance-attribute #

name = name

schemas async #

schemas(context)
Source code in autogen/beta/tools/search/perplexity_search_api.py 
116
117
async def schemas(self, context: Context) -> list[FunctionToolSchema]:
    return await self._tool.schemas(context)

register #

register(stack, context, *, middleware=())
Source code in autogen/beta/tools/search/perplexity_search_api.py 
119
120
121
122
123
124
125
126
def register(
    self,
    stack: ExitStack,
    context: Context,
    *,
    middleware: Iterable[BaseMiddleware] = (),
) -> None:
    self._tool.register(stack, context, middleware=middleware)

set_provider #

set_provider(provider)
Source code in autogen/beta/tools/tool.py 
20
21
def set_provider(self, provider: Provider) -> None:
    pass