Agent Research Assistant

pip install perplexityai pydantic

npm install @perplexity-ai/perplexity_ai

import json
import argparse
from typing import List, Optional
from pydantic import BaseModel
from perplexity import Perplexity


class ReportSource(BaseModel):
    title: str
    url: str
    relevance: str


class ReportSection(BaseModel):
    heading: str
    content: str
    confidence: float
    sources: List[ReportSource]


class ResearchReport(BaseModel):
    title: str
    summary: str
    sections: List[ReportSection]
    conclusion: str
    overall_confidence: float
    total_sources: int


def run_research(topic: str, model: Optional[str] = None) -> ResearchReport:
    """Conduct deep research on a topic and return a structured report."""
    client = Perplexity()

    params = {
        "preset": "medium",
        "input": (
            f"Conduct thorough research on the following topic and produce a "
            f"detailed report with multiple sections, cited sources, and "
            f"confidence scores for each section.\n\nTopic: {topic}"
        ),
        "response_format": {
            "type": "json_schema",
            "json_schema": {
                "name": "research_report",
                "schema": ResearchReport.model_json_schema(),
            },
        },
    }

    if model:
        params["model"] = model

    response = client.responses.create(**params)
    return ResearchReport.model_validate_json(response.output_text)


def format_report(report: ResearchReport) -> str:
    """Format a ResearchReport into human-readable text."""
    lines = [f"{'=' * 60}", f"RESEARCH REPORT: {report.title}", f"{'=' * 60}", ""]
    lines += [f"SUMMARY:", report.summary, ""]

    for i, section in enumerate(report.sections, 1):
        lines.append(f"--- Section {i}: {section.heading} ---")
        lines.append(f"Confidence: {section.confidence:.0%}\n")
        lines.append(section.content)
        if section.sources:
            lines.append("\nSources:")
            for src in section.sources:
                lines.append(f"  - {src.title} ({src.relevance})")
                lines.append(f"    {src.url}")
        lines.append("")

    lines += [f"{'=' * 60}", "CONCLUSION:", report.conclusion, ""]
    lines += [f"Overall Confidence: {report.overall_confidence:.0%}"]
    lines += [f"Total Sources: {report.total_sources}", f"{'=' * 60}"]
    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Agent Research Assistant")
    parser.add_argument("topic", help="The research topic")
    parser.add_argument("--model", help="Override the default model", default=None)
    parser.add_argument("--json", action="store_true", help="Output raw JSON")
    args = parser.parse_args()

    print(f"Researching: {args.topic}")
    print("This may take a moment (deep research uses multi-step reasoning)...\n")

    report = run_research(args.topic, model=args.model)

    if args.json:
        print(json.dumps(report.model_dump(), indent=2))
    else:
        print(format_report(report))


if __name__ == "__main__":
    main()

import Perplexity from "@perplexity-ai/perplexity_ai";

interface ReportSource {
  title: string;
  url: string;
  relevance: string;
}

interface ReportSection {
  heading: string;
  content: string;
  confidence: number;
  sources: ReportSource[];
}

interface ResearchReport {
  title: string;
  summary: string;
  sections: ReportSection[];
  conclusion: string;
  overall_confidence: number;
  total_sources: number;
}

const reportSchema = {
  type: "object" as const,
  properties: {
    title: { type: "string" },
    summary: { type: "string" },
    sections: {
      type: "array",
      items: {
        type: "object",
        properties: {
          heading: { type: "string" },
          content: { type: "string" },
          confidence: { type: "number" },
          sources: {
            type: "array",
            items: {
              type: "object",
              properties: {
                title: { type: "string" },
                url: { type: "string" },
                relevance: { type: "string" },
              },
              required: ["title", "url", "relevance"],
            },
          },
        },
        required: ["heading", "content", "confidence", "sources"],
      },
    },
    conclusion: { type: "string" },
    overall_confidence: { type: "number" },
    total_sources: { type: "number" },
  },
  required: ["title", "summary", "sections", "conclusion", "overall_confidence", "total_sources"],
};

async function runResearch(topic: string, model?: string): Promise<ResearchReport> {
  const client = new Perplexity();

  const params: Record<string, unknown> = {
    preset: "medium",
    input:
      `Conduct thorough research on the following topic and produce a ` +
      `detailed report with multiple sections, cited sources, and ` +
      `confidence scores for each section.\n\nTopic: ${topic}`,
    response_format: {
      type: "json_schema",
      json_schema: { name: "research_report", schema: reportSchema },
    },
  };

  if (model) params.model = model;

  const response = await client.responses.create(params as any);
  return JSON.parse(response.output_text) as ResearchReport;
}

async function main() {
  const topic = process.argv[2];
  if (!topic) {
    console.error("Usage: ts-node research_assistant.ts <topic> [--model <model>] [--json]");
    process.exit(1);
  }

  const modelIdx = process.argv.indexOf("--model");
  const model = modelIdx !== -1 ? process.argv[modelIdx + 1] : undefined;
  const outputJson = process.argv.includes("--json");

  console.log(`Researching: ${topic}`);
  console.log("This may take a moment (deep research uses multi-step reasoning)...\n");

  const report = await runResearch(topic, model);

  if (outputJson) {
    console.log(JSON.stringify(report, null, 2));
  } else {
    console.log(`RESEARCH REPORT: ${report.title}\n`);
    console.log(`SUMMARY: ${report.summary}\n`);
    report.sections.forEach((s, i) => {
      console.log(`--- Section ${i + 1}: ${s.heading} (${(s.confidence * 100).toFixed(0)}%) ---`);
      console.log(s.content);
      s.sources.forEach((src) => console.log(`  - ${src.title}: ${src.url}`));
      console.log();
    });
    console.log(`CONCLUSION: ${report.conclusion}`);
    console.log(`Overall Confidence: ${(report.overall_confidence * 100).toFixed(0)}%`);
  }
}

main();