langchain-perplexity

LangChain Perplexity Skill

Expert assistance for langchain-perplexity: Perplexity AI integration for LangChain. The key differentiator is ChatPerplexity — a chat model with real-time web search built in at the model level, plus domain filtering, date filtering, and reasoning model support.

Install: pip install -U langchain-perplexity
Setup: export PPLX_API_KEY=your_api_key

Reference: references/api.md (500 KB — full API reference).

When to Use This Skill

Activate when:

Using ChatPerplexity — chat completions with built-in real-time web search
Filtering web search by domain — using search_domain_filter to restrict sources
Filtering by date — using search_recency_filter, search_after_date_filter, or search_before_date_filter
Disabling web search — setting disable_search=True to use Perplexity as a plain LLM
Using reasoning models — setting reasoning_effort on sonar-reasoning or sonar-deep-research
Parsing reasoning output — using ReasoningJsonOutputParser or strip_think_tags() to clean <think> tags
Web search for RAG — using PerplexitySearchRetriever to retrieve live search results as documents
Search as a tool — using PerplexitySearchResults in a tool-calling agent
Generating embeddings — using PerplexityEmbeddings
Returning images or related questions — setting return_images=True or return_related_questions=True

Quick Reference

ChatPerplexity — basic usage

from langchain_perplexity import ChatPerplexity

model = ChatPerplexity(
    model="sonar",          # sonar | sonar-pro | sonar-reasoning | sonar-deep-research
    temperature=0.7,
    max_tokens=1024,
    # pplx_api_key="...",   # or set PPLX_API_KEY env var
)

# Invoke (web search runs automatically)
messages = [
    ("system", "You are a helpful assistant."),
    ("human", "What are the latest LangChain releases?"),
]
response = model.invoke(messages)
print(response.content)
print(response.response_metadata)   # includes citations, search results

# Stream
for chunk in model.stream(messages):
    print(chunk.content, end="", flush=True)

Filter web search by domain and recency

from langchain_perplexity import ChatPerplexity

model = ChatPerplexity(
    model="sonar-pro",
    search_domain_filter=["arxiv.org", "github.com"],   # only these sources
    search_recency_filter="week",                        # hour|day|week|month
    # search_after_date_filter="2025-01-01",            # ISO date string
    # search_before_date_filter="2026-01-01",
    return_images=False,
    return_related_questions=True,
)

response = model.invoke("What are recent advances in RAG systems?")

Disable web search (use as plain LLM)

from langchain_perplexity import ChatPerplexity

model = ChatPerplexity(
    model="sonar",
    disable_search=True,    # turn off web search entirely
    temperature=0.5,
)

response = model.invoke("Explain transformer attention mechanisms.")

Reasoning model with effort control

from langchain_perplexity import ChatPerplexity

model = ChatPerplexity(
    model="sonar-reasoning",
    reasoning_effort="high",     # low | medium | high
    temperature=0.2,
)

response = model.invoke("Prove that sqrt(2) is irrational.")
print(response.content)   # final answer (think tags stripped or separated)

Parse reasoning model output

from langchain_perplexity import ChatPerplexity
from langchain_perplexity.output_parsers import (
    ReasoningJsonOutputParser,
    ReasoningStructuredOutputParser,
    strip_think_tags,
)

model = ChatPerplexity(model="sonar-reasoning")
raw = model.invoke("What is 17 * 23? Respond with JSON: {result: number}")

# Option 1: strip <think> tags from raw content
clean_content = strip_think_tags(raw.content)

# Option 2: parse reasoning + answer as structured JSON
parser = ReasoningJsonOutputParser()
parsed = parser.parse(raw.content)
# parsed["thinking"] → reasoning trace
# parsed["answer"] → final answer

# Option 3: structured output with Pydantic
from pydantic import BaseModel

class MathResult(BaseModel):
    result: int

structured_parser = ReasoningStructuredOutputParser.from_pydantic(MathResult)
result = structured_parser.parse(raw.content)

Structured output with ChatPerplexity

from langchain_perplexity import ChatPerplexity
from pydantic import BaseModel, Field

class SearchSummary(BaseModel):
    topic: str = Field(description="The main topic")
    key_points: list[str] = Field(description="Key findings")
    sources: list[str] = Field(description="Source URLs cited")

model = ChatPerplexity(model="sonar-pro")
structured = model.with_structured_output(SearchSummary)
result = structured.invoke("What are the main features of LangGraph?")
print(result.key_points)

PerplexitySearchRetriever — live web search for RAG

from langchain_perplexity import PerplexitySearchRetriever

retriever = PerplexitySearchRetriever(
    k=3,                           # number of documents to return
    search_domain_filter=["docs.langchain.com"],
    search_recency_filter="month",
    # pplx_api_key="...",
)

docs = retriever.invoke("LangGraph StateGraph tutorial")
for doc in docs:
    print(doc.page_content[:200])
    print(doc.metadata)

PerplexitySearchResults — search as a tool in an agent

from langchain_perplexity import PerplexitySearchResults
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent

search_tool = PerplexitySearchResults()

# Use in a ReAct agent alongside other tools
agent = create_react_agent(
    ChatOpenAI(model="gpt-4o-mini"),
    tools=[search_tool],
)
result = agent.invoke({"messages": [("human", "What happened in AI this week?")]})

PerplexityEmbeddings

from langchain_perplexity import PerplexityEmbeddings

embeddings = PerplexityEmbeddings()

# Embed a query
query_vec = embeddings.embed_query("What is LangChain?")

# Embed documents
doc_vecs = embeddings.embed_documents([
    "LangChain is an LLM framework.",
    "Perplexity is an AI search engine.",
])

Model Selection Guide

Model	Speed	Search	Reasoning	Use for
`sonar`	Fast	✅	No	General Q&A, simple factual queries
`sonar-pro`	Medium	✅	No	Complex questions, higher accuracy
`sonar-reasoning`	Slow	✅	✅	Step-by-step reasoning + live facts
`sonar-deep-research`	Very slow	✅	✅	Extensive research, comprehensive reports

API Reference

`ChatPerplexity` key parameters

Param	Type	Description
`model`	`str`	Model name (see table above)
`temperature`	`float`	Sampling temperature
`max_tokens`	`int`	Max tokens to generate
`pplx_api_key`	`str`	API key (or `PPLX_API_KEY` env)
`reasoning_effort`	`str`	`"low"`, `"medium"`, `"high"` for reasoning models
`disable_search`	`bool`	Turn off web search entirely
`search_domain_filter`	`list[str]`	Restrict search to these domains
`search_recency_filter`	`str`	`"hour"`, `"day"`, `"week"`, `"month"`
`search_after_date_filter`	`str`	ISO date: only results after this date
`search_before_date_filter`	`str`	ISO date: only results before this date
`return_images`	`bool`	Include images in response metadata
`return_related_questions`	`bool`	Include related questions in metadata
`language_preference`	`str`	Preferred response language

Output parsers

Class/Function	Description
`strip_think_tags(text)`	Remove `<think>...</think>` from raw content
`ReasoningJsonOutputParser`	Parse reasoning + final JSON answer
`ReasoningStructuredOutputParser.from_pydantic(schema)`	Parse reasoning + Pydantic model

Reference Files

File	Size	Contents
`references/api.md`	500 KB	Full API reference
`references/llms.md`	28 KB	Doc index
`references/llms-full.md`	500 KB	Complete page content

Source: https://reference.langchain.com/python/langchain-perplexity
API Key: https://www.perplexity.ai/settings/api