In this work we present an entity linker for DBLP's 2025 version of RDF-based Knowledge Graph. Compared to the 2022 version, DBLP now considers publication venues as a new entity type called dblp:Stream. In the earlier version of DBLPLink, we trained KG-embeddings and re-rankers on a dataset to produce entity linkings. In contrast, in this work, we develop a zero-shot entity linker using LLMs using a novel method, where we re-rank candidate entities based on the log-probabilities of the "yes" token output at the penultimate layer of the LLM. The demo can be accessed at https://dblplink-2.skynet.coypu.org/.
around two major entity types: Creator and Publication. Subsequently in June 2024, DBLP introduced2 a new entity type dblp:Stream which encompasses multiple sub-classes under the broad category of publication venues, for example, conferences, journals, series and repositories.
Our initial thought was to retrain DBLPLink 1.0 on the new KG and produce DBLPLink 2.0. However, moving DBLPLink 1.0 to a new KG requires computing new KG embeddings for all entities, retraining the entity label span detector, and re-training the re-ranker. In light of recent approaches using LLM-based prompting and zero-shot methods, we decided to build a new architecture from scratch for DBLPLink 2.0. DBLPLink 2.0 is able to link Person and Publication entity types as before, and additionally, can also link Stream entity types. DBLPLink 2.0 can be accessed at https://dblplink-2.skynet.coypu.org/. The code and data used to build this demo can be accessed at https://github.com/semantic-systems/dblplink-2.0.
As seen in Figure 1, the web UI is divided into five elements. A presents a set of question templates which maybe clicked and selected to fill up the text box. B carries the text box where the user may type an input text, and click on Submit to start the entity linking process. C displays a process log which is dynamically updated from the backend, keeping the user informed on the current step being executed. D is results area, where the detected mention spans and their types are displayed. Later, the fetched candidates form the text search are displayed. Finally the linked results are displayed under 2https://blog.dblp.org/2024/06/14/the-dblp-knowledge-graph-major-extension-and-an-update-to-the-rdf-schema/ "Final Linked Results". E is a carousel of sub-pages, which provides further information, such as how to access the entity linker via an API call, more information about the backend entity linker architecture, and details of how to contact the authors and maintainers.
Further, as seen in Figure 2, the final linked results tab, when expanded, displays a sorted list of linked entities by log probability score, per span. The first column is the Span ID, where 0 stands for the first span, 1 stands for the second span and so forth. The second column is the entity label of the candidate as fetched from the Elasticsearch label database. The third column displays the DBLP type for the entity candidate. The fourth column displays the log probability score of the given entity. Note that the scores are in negative, and hence, they appear sorted in descending absolute value scores. The iffth column is also called the evidence sentence, which is the triple that produced the strongest log probability score for among all the triples for this given entity. The sixth column provides a clickable URL link for the entity, which takes the user to the entity’s DBLP page.
Our entity linking pipeline combines prompted large language models (LLMs), type-specific retrieval from an Elasticsearch index, and neighborhood-based re-ranking using KG context. We illustrate the method using the input question:
Who are the co-authors of Ashish Vaswani in "Attention is All You Need" in neurips?
We first extract named entity mentions from the input using a prompted LLM. The prompt is as follows:
You are an information extraction assistant.
Extract named entities from the following sentence and classify them into one of the following types: person, publication, venue.
Let the output be a JSON array of objects with fields ’label’ and ’type’. Not all types may be present in a sentence. Now extract entities from the following sentence: Sentence: "Who are the co-authors of Ashish Vaswani in the ’attention is all you need’ paper in neurips?"
Entities: {"label": "Ashish Vaswani", "type": "person"}, {"label": "attention is all you need", "type": "publication"}, {"label": "neurips", "type": "venue"}
Each extracted label is matched against a type-specific Elasticsearch index to retrieve a list of candidate entities. For example: • "Ashish Vaswani" → [Ashish Vaswani, Vicky Vaswani, ...] • "attention is all you need" → [doi:10.5555/attention-paper, ...
• "neurips" → [NeurIPS, NeurIPS 2022, NeurIPS 2023, ...]
For each candidate entity, we fetch up to one-hop neighbors from a knowledge graph. These triples are converted into readable sequences using a template of the form:
[Head] - [Relation] - [Tail] Example for Ashish Vaswani (author): • Ashish Vaswani - authored - attention is all you need • Ashish Vaswani - affiliated with - Google Brain • Ashish Vaswani - published at - NeurIPS
This yields a set of short sentences describing the local graph structure of each candidate.
Each linearized triple is evaluated by an LLM in the context of the original question. The prompt is:
Given this input text: "Who are the co-authors of Ashish Vaswani in the ’attention is all you need’ paper in neurips?" And the neighborhood context: Ashish Vaswani - authored - attention is all you need Is this the correct entity?
Answer with ’yes’ or ’no’.
We extract the log-probability of the next token being "yes" (before generation), which serves as a soft alignment score for that triple. Each candidate entity receives multiple such scores — one per triple. These are aggregated using mean pooling, where the average log-probability over all triples is computed.
All candidate entities for a given mention are ranked according to their aggregated log-probability scores. The top-ranked candidate is selected as the final linked entity.
The web demo is implemented using the Reflex web development framework 3 which allows building
dynamic web interfaces written purely in Python. For finding optimal parameters for the diferent
components of the entity linker pipeline, we randomly selected a set of 100 questions from the test set
of the DBLP_QuAD dataset [
Due to non-availability of a new entity linking dataset over the current DBLP schema, we were unable to perform extensive evaluation for this task, especially on the new dblp:Stream entity type. Also, because the underlying KGs are diferent, we could not directly compare DBLPLink 2.0’s performance with DBLPLink 1.0. As future, work, we shall prioritise the collection of a new dataset which would allow deeper analysis of our entity linker.
Hits@10 0.0000 0.3100 0.4900 0.4300 0.5000 0.0300 0.4600 0.4000 0.1000 No use of generative AI was made in writing this paper. We relied on the spell-check feature of Sharelatex software which was provided to us by the University of Leuphana as a tool to write research papers. ChatGPT was used for generating the initial templates of the code that the demo runs on. The code was later improved by the authors themselves to make it fully functional.