Entity Resolution with Citation Anchoring Prompt

This prompt is designed for audit, compliance, and investigation teams who must link entity references across multiple documents and produce a decision that an auditor can retrace. The core job-to-be-done is not just merging records, but creating a verifiable evidence chain where every resolution decision—whether a merge, a split, or a deferral—is anchored to a specific source span, page number, or document section. The ideal user is a technical analyst or engineer building a pipeline where traceability is non-negotiable and downstream reviewers will challenge merge decisions. Required context includes a set of documents with stable identifiers, a target entity type to resolve, and an output schema that enforces citation fields. The prompt forces the model to operate as an evidence-first resolver rather than a probabilistic matching engine.

Use this prompt when the cost of an incorrect merge is high—for example, in financial audit trails, legal evidence review, or regulatory compliance filings where conflating two entities could invalidate a report. It is also appropriate when resolution decisions must survive external scrutiny, such as a third-party audit or a legal discovery process. The citation anchoring requirement adds token overhead and increases latency, so do not use this prompt for high-throughput, low-latency pipelines where citation overhead is unnecessary or where entity resolution can be handled by deterministic matching on clean identifiers like email addresses, tax IDs, or database primary keys. If your documents already contain reliable unique identifiers, a simpler deduplication script will outperform this prompt on both cost and accuracy.

Before deploying this prompt, ensure you have a validation harness that checks citation completeness—every merged entity must have at least one source citation per claimed attribute, and every citation must resolve to a real document identifier in the input set. Common failure modes include the model fabricating plausible-sounding page numbers or citing spans that do not exist in the source text. Plan for human review of low-confidence merges and build an escalation path for cases where the model cannot find sufficient evidence to resolve an entity. If your workflow requires real-time resolution or processes thousands of documents per minute, consider using this prompt only for the high-risk subset of entities and routing the rest through a faster deterministic pipeline.

This template is designed for audit and compliance workflows where every entity link must be traceable to its source. It forces the model to anchor each resolution decision to specific text spans, page references, or document sections, producing a structured output that can be validated programmatically before ingestion. Use this when downstream consumers require explainable merge decisions, not just merged records.

textCopy
You are an entity resolution analyst. Your task is to identify and link references to the same real-world entity across multiple provided documents. You must produce resolution decisions that are fully traceable to source evidence.

## INPUT
Documents:
[DOCUMENTS]

Target Entity Types:
[ENTITY_TYPES]

Resolution Rules:
[RESOLUTION_RULES]

## OUTPUT SCHEMA
Return a valid JSON object with the following structure:
{
  "resolved_entities": [
    {
      "canonical_id": "string",
      "entity_type": "string",
      "canonical_name": "string",
      "merged_attributes": {},
      "mentions": [
        {
          "document_id": "string",
          "mention_text": "string",
          "span": {"start": int, "end": int},
          "page": int or null,
          "section": "string or null",
          "confidence": float
        }
      ],
      "resolution_confidence": float,
      "resolution_rationale": "string",
      "conflicts": [
        {
          "attribute": "string",
          "values": ["string"],
          "sources": ["string"],
          "resolution": "string"
        }
      ]
    }
  ],
  "unresolved_mentions": [
    {
      "document_id": "string",
      "mention_text": "string",
      "span": {"start": int, "end": int},
      "reason_unresolved": "string"
    }
  ]
}

## CONSTRAINTS
[CONSTRAINTS]

## EXAMPLES
[EXAMPLES]

## INSTRUCTIONS
1. Extract every mention of the target entity types from all documents.
2. For each mention, record the exact text span, document ID, page, and section.
3. Group mentions that refer to the same real-world entity.
4. Assign a canonical ID and name for each resolved entity.
5. For each resolution decision, provide a confidence score and a rationale that cites specific evidence spans.
6. Flag any conflicting attribute values across mentions and explain how you resolved the conflict.
7. List any mentions you could not resolve and explain why.
8. If confidence for any resolution is below [CONFIDENCE_THRESHOLD], flag it for human review.

Adapt this template by replacing the square-bracket placeholders with your specific inputs. [DOCUMENTS] should contain the full text of each source document with unique identifiers. [ENTITY_TYPES] defines what you're resolving—people, organizations, locations, products. [RESOLUTION_RULES] encodes your matching logic, such as fuzzy name matching thresholds or required corroborating attributes. [CONSTRAINTS] can enforce domain-specific rules like "do not link entities based on email address alone" or "require at least two corroborating attributes for high-confidence merges." [EXAMPLES] should include one correct resolution and one edge case showing how to handle partial matches or conflicts. [CONFIDENCE_THRESHOLD] sets the boundary between automated acceptance and human review.

Before deploying this prompt, validate the output against your downstream ingestion schema. Every span must map to real character offsets in the source documents. Every document_id must match an input document. Run a set of golden resolution pairs through the prompt and measure precision, recall, and citation accuracy. For high-risk domains like compliance or investigations, route all resolutions below your confidence threshold to a human review queue and log every automated merge decision with its full evidence chain for auditability.

This prompt is designed for a single-turn resolution task where the model receives a set of documents and a target entity, then returns a structured decision with anchored citations. The implementation harness must treat the prompt as a deterministic function: input documents and entity query go in, a validated resolution record comes out. Because the output is used for audit and compliance, the harness must enforce strict schema validation, citation integrity checks, and a human review path for low-confidence or conflicting resolutions. Do not stream the output directly to a downstream system of record without passing through these gates.

Validation pipeline: After the model returns its response, run a multi-stage validator. First, parse the JSON output and check that every required field (entity_id, canonical_name, resolution_decision, matched_documents, citations, confidence) is present and correctly typed. Second, for each citation in the citations array, verify that the document_id exists in the input document set and that the span_text is a substring of the referenced document's content. Third, confirm that every matched_documents entry has at least one corresponding citation. If validation fails, log the failure with the raw model output and trigger a retry with the validation errors appended to the prompt as [CONSTRAINTS] feedback. After two failed retries, escalate to a human review queue with the full context and failure log. Model choice: Use a model with strong instruction-following and structured output capabilities (e.g., GPT-4o, Claude 3.5 Sonnet). Set temperature=0 or very low to maximize citation precision. Tool use: This prompt is self-contained and does not require external tools, but the harness should provide a validate_citation_span(document_id, span_text) function that the validator calls to confirm substring presence.

Logging and audit trail: Every resolution decision must be logged with the prompt version, model identifier, input document hashes, raw model output, validation results, and final accepted or escalated status. Store this as an immutable record. For high-risk domains (compliance, legal, financial audit), require a human to sign off on any resolution where confidence < 0.85 or where resolution_decision is conflict_detected. The harness should expose a review endpoint that presents the candidate resolution, source documents with highlighted spans, and validation results side by side. What to avoid: Do not cache resolution results across different document sets without re-running the prompt. Do not silently drop citations that fail span validation—these are signals of hallucination and must be surfaced. Do not use this prompt for real-time, user-facing entity search where latency matters more than auditability; this is a batch or on-demand resolution workflow designed for traceability, not speed.