How to Build an AI-Powered Document Summarizer with API

# Summarize a PDF document
curl -X POST "https://api.tokenall.net.cn/documind/api/v1/summarize" \
  -H "X-API-Key: YOUR_RAPIDAPI_KEY" \
  -F "file=@annual-report-2026.pdf" \
  -F "summary_length=moderate"

{
  "summary": "Acme Corp reported record revenue of $4.2B in FY2026, driven by a 34% increase in cloud services. Key highlights include the acquisition of DataFlow Inc. for $800M, expansion into 12 new markets, and a reduction in operating costs by 8% through automation initiatives. The company raised its FY2027 guidance to $5.0-5.2B, citing strong demand for AI-powered enterprise solutions.",
  "document_length_pages": 48,
  "summary_length": "moderate",
  "language": "en"
}

import requests
import os
from typing import Optional, Literal

class DocumentSummarizer:
    """AI-powered document summarization using the DocuMind API."""

    BASE_URL = "https://api.tokenall.net.cn/documind/api/v1"

    def __init__(self, api_key: str):
        self.headers = {"X-API-Key": api_key}

    def summarize(
        self,
        file_path: str,
        length: Literal["brief", "moderate", "detailed"] = "moderate",
        language: Optional[str] = None
    ) -> dict:
        """Generate an AI summary of a PDF document.

        Args:
            file_path: Path to the PDF file
            length: Summary length - brief (2-3 sentences), 
                    moderate (1 paragraph), detailed (multi-section)
            language: Output language (ISO 639-1 code, e.g. "en", "zh", "es")

        Returns:
            Dict with summary text and metadata
        """
        data = {"summary_length": length}
        if language:
            data["language"] = language

        with open(file_path, "rb") as f:
            response = requests.post(
                f"{self.BASE_URL}/summarize",
                headers=self.headers,
                files={"file": f},
                data=data
            )
        response.raise_for_status()
        return response.json()

    def summarize_batch(self, file_paths: list, length: str = "moderate") -> list:
        """Summarize multiple documents."""
        results = []
        for path in file_paths:
            try:
                result = self.summarize(path, length)
                results.append({
                    "file": path,
                    "summary": result["summary"],
                    "status": "success"
                })
            except Exception as e:
                results.append({
                    "file": path,
                    "error": str(e),
                    "status": "failed"
                })
        return results

# Usage
summarizer = DocumentSummarizer(api_key=os.environ["DOCUMIND_API_KEY"])

# Quick summary
result = summarizer.summarize("contract.pdf", length="brief")
print(f"Brief: {result['summary']}")

# Detailed summary
result = summarizer.summarize("research-paper.pdf", length="detailed")
print(f"Detailed: {result['summary'][:500]}")

from datetime import datetime
from pathlib import Path

class ExecutiveBriefingGenerator:
    """Generate daily executive briefings from incoming documents."""

    def __init__(self, api_key: str):
        self.summarizer = DocumentSummarizer(api_key)

    def generate_briefing(self, document_dir: str) -> str:
        """Process all new documents and generate a consolidated briefing."""
        pdf_files = list(Path(document_dir).glob("*.pdf"))

        if not pdf_files:
            return "No new documents to process."

        summaries = self.summarizer.summarize_batch(
            [str(f) for f in pdf_files], 
            length="moderate"
        )

        # Format as briefing
        briefing = f"# Executive Briefing — {datetime.now().strftime('%Y-%m-%d')}\n\n"
        briefing += f"**Documents processed:** {len(pdf_files)}\n\n"

        for s in summaries:
            filename = Path(s["file"]).stem.replace("-", " ").title()
            if s["status"] == "success":
                briefing += f"## {filename}\n\n{s['summary']}\n\n"
            else:
                briefing += f"## {filename}\n\n⚠️ Failed to process: {s['error']}\n\n"

        return briefing

# Generate today's briefing
generator = ExecutiveBriefingGenerator(api_key=os.environ["DOCUMIND_API_KEY"])
briefing = generator.generate_briefing("./inbox/")
print(briefing)

# Step 1: Get the summary
curl -X POST "https://api.tokenall.net.cn/documind/api/v1/summarize" \
  -H "X-API-Key: YOUR_RAPIDAPI_KEY" \
  -F "file=@technical-spec.pdf" \
  -F "summary_length=moderate"

# Step 2: Use the summary text for embedding
# The summary becomes a dense, high-signal representation of the document

class FullDocumentProcessor:
    def __init__(self, api_key: str):
        self.headers = {"X-API-Key": api_key}
        self.base_url = "https://api.tokenall.net.cn/documind/api/v1"

    def process(self, file_path: str):
        """Extract text, summarize, and convert to Markdown."""
        results = {}

        with open(file_path, "rb") as f:
            file_data = f.read()

        # Extract
        resp = requests.post(
            f"{self.base_url}/extract",
            headers=self.headers,
            files={"file": file_data}
        )
        results["text"] = resp.json()["text"]

        # Summarize
        resp = requests.post(
            f"{self.base_url}/summarize",
            headers=self.headers,
            files={"file": file_data},
            data={"summary_length": "moderate"}
        )
        results["summary"] = resp.json()["summary"]

        # Convert
        resp = requests.post(
            f"{self.base_url}/convert",
            headers=self.headers,
            files={"file": file_data},
            data={"target_format": "markdown"}
        )
        results["markdown"] = resp.json()["content"]

        return results