Build a Contract Analyzer

// app/api/contract/upload/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { Cencori } from 'cencori';
import { setContract } from '@/lib/contract-store';
 
const cencori = new Cencori();
 
export async function POST(req: NextRequest) {
  const form = await req.formData();
  const file = form.get('file');
  if (!(file instanceof File)) {
    return NextResponse.json({ error: 'file required' }, { status: 400 });
  }
 
  const buf = Buffer.from(await file.arrayBuffer());
 
  // One shot: parse the PDF and store the text.
  const result = await cencori.documents.extract({
    document: {
      base64: buf.toString('base64'),
      mimeType: file.type || 'application/pdf',
      filename: file.name,
    },
  });
 
  const contractId = crypto.randomUUID();
  await setContract(contractId, {
    filename: file.name,
    text: result.text,
    pageCount: result.pageCount,
    extractMethod: result.method,
  });
 
  return NextResponse.json({
    contractId,
    pageCount: result.pageCount,
    method: result.method,          // 'pdf_text' means the parse was free
    charCount: result.text.length,
  });
}

// lib/contract-store.ts
const store = new Map<string, { filename: string; text: string; pageCount: number; extractMethod: string }>();
 
export async function setContract(id: string, data: { filename: string; text: string; pageCount: number; extractMethod: string }) {
  store.set(id, data);
}
 
export async function getContract(id: string) {
  return store.get(id);
}

// app/api/contract/[id]/ask/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { Cencori } from 'cencori';
import { getContract } from '@/lib/contract-store';
 
const cencori = new Cencori();
 
export async function POST(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
  const { id } = await params;
  const { question } = await req.json();
 
  const contract = await getContract(id);
  if (!contract) return NextResponse.json({ error: 'not_found' }, { status: 404 });
 
  // Rebuild a data URL so cencori.documents.query re-parses.
  // Simpler: use the text we already cached and hit chat directly.
  // For a full walkthrough we'll use the composed endpoint.
  const result = await cencori.documents.query({
    document: {
      // We stored the text, but the endpoint needs a document.
      // In practice you'd cache the original bytes, not just the text.
      // For this guide, keep the original in your store.
      base64: contract.originalBase64,        // <— add this to setContract
      mimeType: 'application/pdf',
    },
    question,
  });
 
  return NextResponse.json({
    answer: result.answer,
    cost: result.cost.cencoriChargeUsd,
    tokens: result.usage.totalTokens,
  });
}

const response = await cencori.ai.chat({
  model: 'gpt-4o-mini',
  temperature: 0,
  messages: [
    {
      role: 'system',
      content:
        'You answer questions strictly from the provided document. ' +
        'If the answer is not present, say "Not found in the document." ' +
        'Do not invent details. Include short quoted excerpts when useful.',
    },
    { role: 'user', content: `Document:\n\n${contract.text}\n\n---\n\nQuestion: ${question}` },
  ],
});

// app/contract/page.tsx
'use client';
 
import { useState } from 'react';
 
export default function ContractPage() {
  const [contractId, setContractId] = useState<string | null>(null);
  const [question, setQuestion] = useState('');
  const [answer, setAnswer] = useState<string | null>(null);
  const [loading, setLoading] = useState(false);
 
  async function handleUpload(e: React.ChangeEvent<HTMLInputElement>) {
    const file = e.target.files?.[0];
    if (!file) return;
    setLoading(true);
    const form = new FormData();
    form.append('file', file);
    const res = await fetch('/api/contract/upload', { method: 'POST', body: form });
    const data = await res.json();
    setContractId(data.contractId);
    setLoading(false);
  }
 
  async function handleAsk() {
    if (!contractId || !question) return;
    setLoading(true);
    setAnswer(null);
    const res = await fetch(`/api/contract/${contractId}/ask`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ question }),
    });
    const data = await res.json();
    setAnswer(data.answer);
    setLoading(false);
  }
 
  return (
    <div className="mx-auto max-w-2xl space-y-6 p-8">
      <h1 className="text-2xl font-semibold">Contract Q&amp;A</h1>
 
      {!contractId && (
        <label className="block cursor-pointer rounded-lg border-2 border-dashed p-8 text-center">
          <input type="file" accept="application/pdf" className="hidden" onChange={handleUpload} />
          {loading ? 'Parsing…' : 'Click to upload a PDF'}
        </label>
      )}
 
      {contractId && (
        <div className="space-y-3">
          <textarea
            value={question}
            onChange={(e) => setQuestion(e.target.value)}
            placeholder="What is the termination clause?"
            className="w-full rounded-lg border p-3"
            rows={2}
          />
          <button onClick={handleAsk} disabled={loading} className="rounded-lg bg-neutral-900 px-4 py-2 text-white">
            {loading ? 'Thinking…' : 'Ask'}
          </button>
 
          {answer && (
            <div className="rounded-lg border bg-neutral-50 p-4 whitespace-pre-wrap dark:bg-neutral-900">
              {answer}
            </div>
          )}
        </div>
      )}
    </div>
  );
}