Spectre AI — Powered by ChatGPT 5.

In 2025, everything is “AI” — your phone, your fridge, even your toaster if it lights up on its own.

But at Pak Legal Database, we don’t just throw around buzzwords. This isn’t “powered by GPT” and hope for the best. It’s a multi layered- Agentic RAG Model , multilingual, citation-aware legal assistant built on over 100,000+ Pakistani case laws, engineered to retrieve real precedent and respond like a trained legal research assistant.

What’s Under the Hood: How Our AI Actually Works

Step 1: What Is RAG?

RAG stands for Retrieval-Augmented Generation. It means the model doesn't rely on memory alone — it searches a database, retrieves relevant material, and uses that to form responses and reduce AI hallucinations. To acheive this:

• We’ve indexed 138,000+ judgments and legislative documents using vector embeddings
• The system retrieves the most relevant cases per query
• GPT-5 then composes a structured, contextual response — with citations

Why Basic RAG Isn't Enough

A typical RAG system:

• Runs the query once
• Retrieves a few documents
• Outputs a basic answer — no reasoning, no loop, no validation

So we built something smarter — Agentic RAG.

What Is Agentic RAG?

Agentic RAG uses modular AI agents — each with its own role, short-term memory, and dedicated tools — that collaborate to refine and validate responses:

• Query Agent: Understands legal context + keywords
• Retrieval Agent: Searches vector DB and fetches top 5 matches
• Formatter Agent: Structures Title, Citation, Summary
• Multilingual Agent: Handles English, Urdu, and hybrid phrases
• Answering Agent: Parses iterations of RAG Agents and constructs the final answer (simplified)

Comparison: Basic RAG vs Agentic RAG

Feature	Basic RAG	Agentic RAG
Access to multiple tools	❌	✅
Multi-step reasoning	❌	✅
Validates retrieved context	❌	✅
Modular agent roles	❌	✅
Language adaptation	❌	✅
Real-time internet use	❌	✅

How We Built It (Tech Stack)

• GPT-5 (OpenAI) – advanced reasoning, multilingual legal parsing, deep contextual understanding
• Botpress – agent coordination + tool calling
• Custom Retrievers – trained on Pakistani legal terminology
• Vector Database – semantic case search
• Secure API Layer – real-time DB + API layer + auth
• Tool Functions – allows AI to interact directly with live case data and the internet

Oversimplified example of Agentic RAG pipeline — all core steps in one place.

This is the logic used to retrieve relevant case law dynamically:

def agentic_legal_search(user_input: str, top_k: int = 5) -> str:
    """
    Simulates an Agentic RAG pipeline for legal research — all in one function.
    Parses query, handles multilingual input, retrieves and formats legal case summaries.
    """
    # Step 1: Detect and translate (Multilingual Agent)
    if not user_input.isascii():
        user_input = translate_to_english(user_input)  # Simulated translation

    # Step 2: Extract keywords and refine (Query Agent)
    query = extract_legal_keywords(user_input)  # Optional keyword extraction

    # Step 3: Retrieve top results from vector DB (Retrieval Agent)
    results = vector_db.search(query, top_k=top_k)
    if not results:
        return "No relevant case law found."

    # Step 4: Format output with title, citation, and summary (Formatter Agent)
    formatted = []
    for idx, r in enumerate(results, 1):
        title = r.get("title", "Untitled Case")
        citation = r.get("citation", "No Citation")
        summary = r.get("summary", "No summary available.")
        formatted.append(f"{idx}. {title} ({citation})\n   Summary: {summary}")

    # Step 5: Final composition / reasoning (Answering Agent)
    return "\n".join(formatted)
  

So... What Can Our AI Legal Assistant Actually Do?

• Understands legal queries: Ask about Article 25, Section 302, bail — it will explain it or find relevant citations
• Retrieves real judgments: No hallucinations, no fluff
• Returns citations and summaries: PLD/SCMR/LHC/SCP etc with titles and summaries
• Supports multilingual phrasing: English, Urdu, and code-switching
• Built for unlimited use: Vision agent is paused to keep usage scalable

TL;DR

• Retrieves real judgments from 100,000+ cases
• Shows up to 5 relevant cases per query
• Returns citation, title, and summary — no fluff
• Multilingual support (English, Urdu, mixed phrases)
• Temporarily paused vision agent for cost-free usage
• Built with GPT-4o, Botpress, Custom API Layers, and Custom Agentic RAG Models.

🧠 Hallucinations: A Known Limitation in All AI Systems

Despite advanced architecture and real-time legal data, SpectreGPTJ — like all AI systems — is not entirely free from "hallucinations". A hallucination occurs when an AI model confidently generates an incorrect, misleading, or completely fabricated answer. This is a well-documented limitation, even in the most advanced large language models.

• The official GPT-4 Technical Report acknowledged that while GPT-4 made substantial improvements over GPT-3.5, hallucinations still occur and were only reduced — not eliminated.
• Subsequent third-party benchmarks revealed that GPT-4o (OpenAI’s optimized version of GPT-4) had hallucination rates of up to 61.8% in open-ended tasks, which were later improved to 37.1% in GPT-4.5 (Reuters, 2025).
• SpectreGPTJ minimizes these issues by relying on a retrieval-augmented generation (RAG) framework trained exclusively on real Pakistani case law — meaning it tries to “look things up” from trusted data rather than inventing them.

However, hallucinations may still happen — especially when:

• The input is ambiguous, overly complex, or lacks proper legal context
• The chat thread becomes too long or stale
• There’s a rare retrieval mismatch or error in context synthesis

✅ Solution: If you notice incorrect, repetitive, or nonsensical answers, simply refresh the chat using the icon in the top-right corner. This clears the agent chain and often resolves the issue immediately.

⚙️ Limitations of RAG and Agentic RAG Systems

SpectreGPTJ operates on a cutting-edge Agentic RAG framework, which combines multiple modular agents — each designed for a specific legal research task. This is far more powerful than basic RAG systems that run a single query and generate a flat response. However, the complexity introduces its own limitations.

In a typical SpectreGPTJ interaction, your input goes through a pipeline of 5 to 6 specialized agents: query parsing, multilingual handling, vector search, formatting, citation validation, and final response generation. These agents communicate in sequence and loops, meaning each query may undergo up to 12 steps before the final answer is delivered.

This multi-agent orchestration has two major consequences:

• ⏳ Speed Tradeoff: Because multiple AI agents interact, responses can sometimes feel slower than a simple chatbot. Each step adds processing time — especially when reasoning, formatting, or translation are involved.
• 🎯 Distributed Risk: If even one agent out of six starts to hallucinate, lag, or return improper data — the entire final answer may be affected. This is a known limitation of agent-based AI systems, especially in domains with narrow or high-stakes information like law.

We’ve minimized these risks with validation loops, fallback prompts, and retrieval scoring — but there’s no such thing as perfect harmony in distributed AI orchestration.

🔗 Ready to try it? Head over to www.paklegaldatabase.com and start your legal research — powered by SpectreGPTJ.