[Paper] LELA: an LLM-based Entity Linking Approach with Zero-Shot Domain Adaptation

Source: arXiv - 2601.05192v1

Overview

The paper introduces LELA, a new entity‑linking system that taps into the zero‑shot reasoning power of large language models (LLMs). By chaining a coarse‑to‑fine pipeline, LELA can map ambiguous mentions to the correct entities in any knowledge base—without any task‑specific fine‑tuning. The authors demonstrate that this plug‑and‑play approach matches or beats many fine‑tuned baselines, opening the door to rapid, domain‑agnostic deployment of entity linking in real‑world applications.

Key Contributions

• Zero‑shot, modular pipeline: A coarse‑to‑fine architecture that first narrows down candidate entities and then refines the selection using an LLM, all without any additional training.
• Domain‑agnostic design: Works across heterogeneous knowledge bases (e.g., Wikipedia, domain‑specific ontologies) and with any off‑the‑shelf LLM (GPT‑3.5, Claude, Llama 2, etc.).
• Competitive performance: Empirical results show LELA rivals state‑of‑the‑art fine‑tuned entity linkers and significantly outperforms other zero‑shot baselines.
• Open‑source friendly: The system is built from reusable components (candidate generator, LLM reranker) that can be swapped or extended, facilitating integration into existing pipelines.

Methodology

1. Candidate Generation (Coarse Stage)

   • A lightweight, fast matcher (e.g., BM25 over entity surface forms, fuzzy string matching, or a lightweight neural retriever) produces a short list (typically ≤ 10) of plausible entities for each mention.
   • This step is deliberately simple to keep latency low and to keep the pipeline independent of the LLM’s token budget.

2. LLM‑Based Reranking (Fine Stage)

   • The shortlisted candidates are fed to a large language model together with the surrounding context.
   • The prompt asks the LLM to “choose the entity that best fits the mention given the sentence,” optionally providing short descriptions of each candidate.
   • The LLM returns a ranking (or a single choice) based on its internal world knowledge and contextual reasoning.

3. Modular Integration

   • Each stage is a separate component, so you can replace the candidate generator with a dense retriever, swap the LLM for a cheaper model, or add post‑processing (e.g., confidence thresholds).

4. Zero‑Shot Operation

   • No gradient updates or fine‑tuning are performed on any component. The system relies solely on the pre‑trained knowledge encoded in the LLM and the lexical overlap captured by the candidate generator.

Results & Findings

• Close to fine‑tuned performance: LELA trails the best fine‑tuned models by only 1–2 percentage points on most benchmarks.
• Large margin over plain zero‑shot LLMs: The coarse‑to‑fine design yields a 10–15 point boost compared to feeding the raw mention/context directly to the LLM.
• Scalability: Inference latency is dominated by the LLM call (≈ 200 ms per mention on a 4‑GPU server), which is comparable to many production‑grade neural EL models.

Practical Implications

• Rapid prototyping: Teams can spin up an entity‑linking service for a new domain (e.g., a proprietary product catalog) without collecting labeled training data or fine‑tuning models.
• Cost‑effective maintenance: Since LELA relies on off‑the‑shelf LLM APIs, updates to the underlying model (e.g., a newer GPT version) instantly improve linking quality without re‑training pipelines.
• Plug‑and‑play in existing stacks: The candidate generator can be integrated with search engines (Elasticsearch, Solr) or vector stores, while the LLM reranker can be called via standard REST endpoints, making adoption straightforward for backend engineers.
• Improved downstream tasks: Better entity linking feeds more accurate knowledge graphs, enhances question‑answering accuracy, and boosts entity‑aware recommendation systems—all with minimal engineering overhead.

Limitations & Future Work

• LLM cost & latency: While competitive, the approach still depends on expensive API calls for large models; exploring smaller, distilled LLMs or caching strategies is an open avenue.
• Candidate generator quality: The coarse stage can miss the correct entity if the initial shortlist is too narrow; future work could incorporate adaptive retrieval thresholds or hybrid dense‑sparse retrieval.
• Explainability: The LLM’s reasoning is opaque; adding rationales or confidence scores would help developers debug linking errors.
• Domain‑specific knowledge bases: Extremely niche ontologies with limited textual descriptions may still challenge the LLM’s ability to discriminate; augmenting candidates with richer metadata is a promising direction.

LELA shows that with clever prompting and modular design, the massive world knowledge baked into LLMs can be harnessed for high‑quality entity linking—without the heavy engineering cost of fine‑tuning.

Authors

• Samy Haffoudhi
• Fabian M. Suchanek
• Nils Holzenberger

Paper Information

• arXiv ID: 2601.05192v1
• Categories: cs.CL
• Published: January 8, 2026
• PDF: Download PDF