Author(s): Felix Pappe Originally published on Towards AI. Image created by the author using gpt-image-1 AI chatbots and advanced Retrieval-Augmented Generation (RAG) systems are increasingly adept at providing up-to-date, context-aware answers based on previously retrieved text chunks. However, despite their seemingly reliable responses, the significant issue remains, that users often lack a clear method to verify the source of these answers without having to return to the original, often lengthy, documents themselves. This is particularly cumbersome when the source is a multi-page academic paper, technical manual, or book. Even when a link is provided, users are left searching through dozens of pages, trying to locate the exact section that the chatbot used for the generation of the final response. This manual cross-checking is not only time-consuming, it undermines trust in the LLM’s output.As a result, AI-generated answers may appear correct at first glance but remain opaque, leaving users uncertain about their reliability. This lack of verifiability can lead to misinformation and misinterpretation. In this blog post, I would like to offer a solution to this problem with a visual grounding approach using the Docling parsing tool, Qdrant vector store, and LangChain. This RAG framework doesn’t just retrieve relevant text. It also highlights the exact location of the extracted text directly on the page from the source document.By connecting answers to theirLLM’s output.The result is a transparent, verifiable, and user-friendly RAG framework that builds trust while maintaining accuracy, which is built in this blog post. Docling The foundation of the visual grounding approach introduced in this blog post is the Docling document processing pipeline. Docling is an open-source tool for layout-aware document parsing and grounding, achieving results comparable to paid solutions like Mistral OCR.Moreover, docling provides an additional key feature for visual grounding, which other document-to-markdown solutions don’t have. This feature is the decomposition of the input document into smaller sub-elements, including headings, text chunks, formulas, and tables, using different models in a sophisticated processing pipeline, which is presented in the following image.Docling Pipeline from docling paper The output of this processing pipeline is not a markdown file but a DoclingDocument, which consists of all the detected and extracted elements from the input document. This intermediate DoclingDocumentclass, enhanced with metadata from extracted elements, allows for the transformation of the original document into various file types and supports the visual grounding discussed in this blog post.RAG framework Like all RAG frameworks, this one consists of two phases that can be divided into two scripts. In the offline indexing phases, input documents are split into chunks and encoded into vector representations. These vectors are stored in a specialized vector database for later retrieval.In the online retrieval and generation phase, text chunks related to a user’s input are retrieved and passed to the LLM to generate a final response.These two phases are implemented in two separate scripts in this post.The following image illustrates the final visual grounding result produced by the two scripts explained in this blog post. In the first Python script, the Docling paper is uploaded to a Qdrant vector store during the offline indexing phase. In the second script, relevant passages are retrieved based on a given question and are then highlighted directly on the document.Image created by author and designed in canva Indexing phase The indexing script handles data preprocessing and stores the embedded text chunks in a vector database for the second online retrieval phase. I split the script into several parts to explain in detail what happens at each part, providing a deeper understanding of the entire code. Imports Let’s start very gently with the import of all required libraries and packages, including docling, langchain, and qdrant. import osfrom pathlib import Pathfrom uuid import uuid4from dotenv import load_dotenvfrom transformers import AutoTokenizerfrom qdrant_client import QdrantClientfrom qdrant_client.http.models import Distance, VectorParamsfrom langchain_qdrant import QdrantVectorStorefrom langchain_huggingface.embeddings import HuggingFaceEmbeddingsfrom docling.datamodel.base_models import InputFormatfrom docling.datamodel.pipeline_options import PdfPipelineOptionsfrom docling.document_converter import DocumentConverter, PdfFormatOptionfrom docling.chunking import HybridChunkerfrom langchain_docling.loader import DoclingLoader, ExportTypefrom docling_core.types.doc import ImageRefMode Configuration and environment variables In the next step, the environmental variables are loaded from the .env file and read in with getenv(). Inside the .env file, your HF_TOKEN for the embedding model and your MISTRAL_API_KEY for the LLM must be included. Of course, you can also adjust the code to your needs and choose any other embedding model or LLM. But if you change the embedding model, also change the DIM variable, which refers to the final vector dimensions of the embedded chunks.Afterwards, the docling processing pipeline is defined, enabling all functionalities to generate a complete DoclingDocument. This pipeline includes the detection and extraction of code blocks, formulas, tables, pages, and page images of the document. Moreover, the extracted images are scaled by 2.0 for a higher resolution. load_dotenv() HF_TOKEN = os.getenv("HF_TOKEN")MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY")SOURCES = ["attention-04.pdf"]OUTPUT_DIR = Path("output")OUTPUT_DIR.mkdir(parents=True, exist_ok=True)EMBED_MODEL = "sentence-transformers/all-MiniLM-L6-v2"COLLECTION_NAME = "demo_collection"DIM = 384pipeline_options = PdfPipelineOptions( do_code_enrichment=True, do_formula_enrichment=True, do_table_structure=True, generate_picture_images=True, generate_page_images=True, images_scale=2.0,)pipeline_options.table_structure_options.do_cell_matching = True Setting up document converter In the next step, the DocumentConverter from Docling is configured using the previously defined pipeline options. Later in the code, this converter will be used to transform an input PDF into a DoclingDocument, which consists of modular components such as headings, text paragraphs, images, and tables. Furthermore, the embedding model is initialized, which is necessary to embed the extracted sentences from the document into a vector representation. converter = DocumentConverter( format_options={ InputFormat.PDF: PdfFormatOption(pipeline_options=pipeline_options) })embeddings = HuggingFaceEmbeddings(model_name=EMBED_MODEL) Initialize qdrant collection A local Qdrant vector storage is then set up, allowing you to experiment with the script on your device. It either creates a new vector storage if none exists with the current name or connects to an existing one if there is a match. client = QdrantClient(path="langchain_qdrant")collections = [col.name for col in client.get_collections().collections]if COLLECTION_NAME not in collections: client.create_collection( collection_name=COLLECTION_NAME, vectors_config=VectorParams(size=DIM, distance=Distance.COSINE), ) print(f"Created new collection '{COLLECTION_NAME}'.")else: print(f"Using existing collection '{COLLECTION_NAME}'.") vector_store = QdrantVectorStore( client=client, collection_name=COLLECTION_NAME, embedding=embeddings,) Convert pdf to docling and save outputs Subsequently, all PDF files listed in the SOURCE are converted into DoclingDocuments and saved in dl_doc. These documents are then transformed into JSON and markdown files, which are stored on your local device. The markdown file is used to assess the quality of the file transformation process, while the JSON file is necessary for the subsequent visual grounding process in the second script. for source in SOURCES: dl_doc = converter.convert(source=source).document # JSON export out_json = OUTPUT_DIR / f"{dl_doc.origin.binary_hash}.json" dl_doc.save_as_json(out_json) # Markdown export with embedded images out_md = OUTPUT_DIR / f"{dl_doc.origin.binary_hash}.md" dl_doc.save_as_markdown(out_md, image_mode=ImageRefMode.EMBEDDED) Chunking the document Finally, we come to the main part of the script, including the chunking process of the document into smaller texts. This is achieved using the HybridChunker provided by docling. The best feature of this HybridChunker is that it tries to keep related passages together based on the markdown formatting and merges passages with each other if they are too small. A small max_tokens size has been selected to implement a small-to-big retrieval approach. This means that initially, a small chunk of text that closely matches the user's query is retrieved. Following this, a larger context chunk that surrounds the retrieved section is additionally retrieved and provided to the language model for generating the final answer. In this case, the larger context chunk refers to the paragraph containing the smaller chunk. chunker = HybridChunker( tokenizer=EMBED_MODEL, max_tokens=64, merge_peers=True)loader = DoclingLoader( file_path=SOURCES, converter=converter, export_type=ExportType.DOC_CHUNKS, chunker=chunker,)docs = loader.load() Embedding the document In the final step, the generated chunks are stored in the vector database with a unique identifier, from which they can be retrieved during the online phase. ids = [str(uuid4()) for _ in docs]vector_store.add_documents(documents=docs, ids=ids)print("Documents have been embedded into the vector store.") Retrieval and generation part Now, the online retrieval and generation part leverages the previously embedded text chunks to generate an answer for the user’s input based on the knowledge in the vector store. Imports As in the previous indexing script, all the necessary packages are included first. import osimport refrom pathlib import Pathfrom dotenv import load_dotenvfrom PIL import ImageDraw, Imagefrom pydantic import BaseModel, Fieldfrom qdrant_client import QdrantClientfrom langchain_core.output_parsers import PydanticOutputParserfrom langchain_core.prompts import PromptTemplatefrom langchain_huggingface.embeddings import HuggingFaceEmbeddingsfrom langchain_mistralai import ChatMistralAIfrom langchain_qdrant import QdrantVectorStorefrom docling.chunking import DocMetafrom docling.datamodel.document import DoclingDocument Configuration and environment variables Then, the necessary environment variables are loaded and configuration variables are set. load_dotenv()MISTRAL_API_KEY = os.environ["MISTRAL_API_KEY"]OUTPUT_DIR = Path("output")EMBED_MODEL = "sentence-transformers/all-MiniLM-L6-v2"COLLECTION_NAME = "demo_collection"QUESTION = ( "How does attention is computed in the transformer architecture?")TOP_K = 3OUTPUT_DIR.mkdir(parents=True, exist_ok=True) Build JSON lookup table In the next step, all JSON files in the OUTPUT directory are detected. For each file, its name is extracted using the stem method. Afterwards, it’s verified that the name consists only of digits, representing the hash value of the file, before adding the numeric name as a key and the file’s path as a value in the doc_store dictionary. Initializing embedding model, vector store, and llm After that, the embedding model and the LLM are initialized. It is important to use the same embedding model and Qdrant collection name as in the previous indexing script. Optionally, you may want to define these names in a separate configuration script and import this script into both the indexing and retrieval scripts. For the LLM, I selected Mistral, but you can also choose GPT-4, Gemini, Llama, or any other model you prefer. embeddings = HuggingFaceEmbeddings(model_name=EMBED_MODEL)client = QdrantClient(path="langchain_qdrant")try: client.get_collection(collection_name=COLLECTION_NAME)except Exception: print( f"Collection {COLLECTION_NAME} not found; create it before indexing.")vector_store = QdrantVectorStore( client=client, collection_name=COLLECTION_NAME, embedding=embeddings,)llm = ChatMistralAI( api_key=MISTRAL_API_KEY, model="mistral-large-latest", temperature=0, max_retries=2,) Preparing the chain Thereafter, all components of the RAG chain are set up, beginning with the Answer Pydantic schema, which consists of two fields. The first field, answerable is a boolean value that indicates whether the question can be answered using the retrieved knowledge. The second field, answer provides the actual response. This structure is employed to address the hallucination issue that many LLMs encounter, helping to prevent the dissemination of incorrect information to the user.Following that, the PydanticOutputParser and its get_format_instructuons() method format_instructuons generate the format instructions for the LLM. Moreover, the parser is employed again as the final Runnable of the LangChain execution chain, with its elements connected by the | operator. The prompt created for the PromptTemplate is basic and can be further enhanced by the introduction of few-shot examples or other advanced prompt engineering techniques. class Answer(BaseModel): answerable: bool = Field( ..., description="Whether the question can be answered" ) answer: str = Field( ..., description="The answer based on the provided knowledge" ) parser = PydanticOutputParser(pydantic_object=Answer)format_instructions = parser.get_format_instructions()prompt = PromptTemplate( input_variables=["knowledge", "topic"], partial_variables={"format_instructions": format_instructions}, template=( "You are given the following grounding material:\n\n" "{knowledge}\n\n" "Question:\n" "{topic}\n\n" "Please provide a concise answer in full sentences " "based solely on the information above.\n" "If the answer is not contained within the provided material, " "reply with:\n" "“There is no answer to this question in the provided material.”\n\n" "{format_instructions}" ),)rag_chain = prompt | llm | parser Run similarity search Once the chain has been set up. The text chunks semantically related to the user input query are retrieved. results = vector_store.similarity_search_with_score( k=TOP_K, query=QUESTION) Load and assemble grounding texts Based on the retrieved text chunks from the vector database, the entire paragraph containing each chunk is loaded. This approach is inspired by the small-to-big retrieval technique introduced earlier. Image created by the author, designed with canva and graphics generated using gpt-image-1 The relevant paragraph is pulled from the JSON file associated with the document from which the chunk originates. The correct JSON file is identified by the document’s hash value, which appears both in the text chunk’s metadata and in the JSON filename. Once the correct JSON file is identified, it’s loaded via the load_from_json method of the DoclingDocument. The original text item referenced in the current result chunk’s metadata is then extracted from the JSON file using a regular expression. If the referenced text item is found, the full text passage is retrieved to generate the final result. This example focuses exclusively on text grounding. However, Docling also provides references to previously identified images and tables. grounding_texts: list[str] = []for res, score in results: meta = DocMeta.model_validate(res.metadata["dl_meta"]) h = meta.origin.binary_hash json_file = doc_store.get(h) if not json_file: continue dl_doc = DoclingDocument.load_from_json(json_file) for item in meta.doc_items: if not item.prov: continue match = re.search(r"^#/texts/(\d+)$", item.self_ref) if not match: continue idx = int(match.group(1)) grounding_texts.append(dl_doc.texts[idx].text.strip())knowledge = "\n\n".join(grounding_texts)print("Assembled grounding material:\n", knowledge) Invoke the llm Finally, the LLM can be invoked using the previously defined chain. Inside the invoke method, the retrieved knowledge passages from the original JSON file and the user’s input question are passed in. The returned values conform to the defined AnswerPydantic schema for a structured evaluation the results. answer_obj = rag_chain.invoke( {"knowledge": knowledge, "topic": QUESTION})print("Answerable?", answer_obj.answerable)print("Answer: ", answer_obj.answer) Visual grounding The subsequent script proceeds to visually ground the used chunks in the corresponding documents only if the question can be answered based on the provided content, meaning the LLM returns that answerable is equal to true/1. This grounding process is approached similarly to how original text passages are extracted from documents. However, this time, the focus is on the bounding boxes surrounding these text passages instead of the raw text itself. These bounding boxes are another outcome of the document analysis and processing performed by the Docling pipeline in the indexing script. Now, these boxes can be utilized to anchor the generated answers to the original pages of the document. The coordinates of these bounding boxes come also from the metadata of each chunk, Moreover, the metadata of a chunk includes the page number, which is required to extract the screenshot of the correct page from the corresponding file. This screenshot of the page is the foundation for the visual grounding process, as bounding boxes are added on top of it. In the end, these bounding boxes are on top of the retrieved image of the correct side, allowing the user to precisely identify from which part of the document the information was retrieved. The final visually enhanced images are then stored in the same output directory as the input document and are ready for visual inspection. if answer_obj.answerable: for i, (res, score) in enumerate(results, start=1): meta = DocMeta.model_validate(res.metadata["dl_meta"]) h = meta.origin.binary_hash json_file = doc_store.get(h) if not json_file: continue dl_doc = DoclingDocument.load_from_json(json_file) image_by_page: dict[int, "Image.Image"] = {} for item in meta.doc_items: if not item.prov: continue prov = item.prov[0] p = prov.page_no if p not in image_by_page: image_by_page[p] = dl_doc.pages[p].image.pil_image.copy() img = image_by_page[p] bbox = prov.bbox.to_top_left_origin( page_height=dl_doc.pages[p].size.height ).normalized(dl_doc.pages[p].size) left = round(bbox.l * img.width) - 2 top = round(bbox.t * img.height) - 2 right = round(bbox.r * img.width) + 2 bottom = round(bbox.b * img.height) + 2 draw = ImageDraw.Draw(img) draw.rectangle([left, top, right, bottom], outline="blue", width=2) for p, img in image_by_page.items(): out_png = OUTPUT_DIR / f"source_{i}_page_{p}.png" img.save(out_png) print(f"Saved annotated page {p} → {out_png}") Limitation However, no solution is without flaws, and this one is no exception. The first point to consider is the heavy reliance on Docling. This tool is deeply integrated into the RAG framework, as it is used in almost every part of the system, including document parsing, text chunking, and grounding the final answer, which depends on the DoclingDocument class. Another point is the processing speed and resource requirements. While the advantage of Docling is that it can be deployed entirely on your local device, its processing speed and the maximum manageable file size depend significantly on your hardware. If your hardware is not powerful enough, you may only be able to parse one page of a document at a time. Additionally, a limitation of the provided example in this blog post is its focus solely on text. It ignores images and tables that also contain rich information and leaves space for further enhancements. Conclusion But despite these limitations, Docling is a neat way to enhance advanced RAG frameworks quickly with additional visual grounding capabilities. By connecting retrieved answers directly to their visual origin, this approach not only boosts transparency but also helps users build trust in the system’s output. What is your opinion about Docling and this introduced RAG framework? Have you already experimented with other grounding approaches for more explainable AI?Sources Docling Paper: https://arxiv.org/abs/2501.17887 Docling Documentation: https://docling-project.github.io/docling/ Qdrant local quickstart: https://qdrant.tech/documentation/quickstart/ LangChain ChatMistralAI: https://python.langchain.com/docs/integrations/chat/mistralai/ LangChain structured outputs: https://python.langchain.com/docs/concepts/structured_outputs/ Join thousands of data leaders on the AI newsletter. Join over 80,000 subscribers and keep up to date with the latest developments in AI. From research to projects and ideas. If you are building an AI startup, an AI-related product, or a service, we invite you to consider becoming a sponsor. Published via Towards AI

Eleven years after Google first announced its grand unifying theory of design—Material Design—it’s introducing its third major revision to the system.Called Material 3 Expressive, the company will tell you that it’s their most “researched update” ever, promising to help people find what they’re looking for on the screen faster than before. But it’s also the company’s most maximalist design system to date. Still enabling quieter minimalist designs, sure, but embracing bolder colors, more playful animations, and all around more overt approaches to interface. There’s a new roundness to almost every component, right down to the tips of Google’s new default typeface, Google Sans Flex Rounded, which replaces the hard edged terminals on letterforms with smooth tips.[Image: Google]But mostly, Google is using more of everything to accentuate contrast, like between headers and bodies. Button shapes can now be anything from giant pills to stars. Perkier animations rekindle tech’s old favorite words, “joy” and “delight,” with a bit more springiness in them across the board. And UI elements on your screen often react to others—dial a phone number, and each digit you press bounces the others out of the way like cartoony bubble tape.“It’s kind of like the next evolution,” says Vanessa Cho, VP, Google Design. “It’s design with the soul. What I mean by that is it’s [still] driven with deep purpose…but it also connects with you on the emotional level.”[Image: Google]The history of Material DesignMaterial Design was born over a decade ago, as Google Designers developed a grounding metaphor to codify its otherwise fragmented approach to design. Inspired by light and paper, Material Design was like a stretchy piece of wonder paper that could reshape to do anything, and it brought a sense of tactile physics to Search, Android, and other Google Services.In the years since, Material Design veered from its ambitious roots. It imagined eventually breaking out of screens and becoming the interface for our lives—what would be a better interface for an internet of things than literal matter that would reshape itself in front of you? Material Design was built for a path toward that smart infrastructure that seemed so inevitable in the 2010s. But a decade later, and the world didn’t play out that way. Instead, most things stayed dumb as we got sucked deeper and deeper into our phones. The stoic minimalism that Material Design v 1 celebrated got washed out by the pixel onslaughts of TikTok and other social media platforms. The emoji of 2014 seem quaint by the comparison of just about everything on Instagram, where even AI characters are attempting to be my bff.So in 2021, Material Design pivoted. It became more about personalization—allowing your phone to have a color palette and typefaces more reflective of you. And now? Material Design is trending more maximal, with an overt approach to design that’s willing to call attention to itself as a moment of celebration, rather than disappear into the background.[Image: Google]“We’re in an era of expression…thinking about TikTok and whatever you’re on,” says Mindy Brooks, VP, Product & UX, Android Platform. “So this design system allows us to, even as developers and creators of it, to express what we want to in the product.”Testing and manifestingAcross Google’s products, these new design standards play out in different ways. On Android, it means we see apps presented in a greater array of typefaces (pushing expressiveness and information hierarchy at the same time), while apps like Photos trend toward the Canva-create-a-card vibes we get on iOS today. On Wear OS, the colors from your phone can be mirrored on your wrist, and buttons now wrap all the way into the curves of the display through a lovely marriage of device and UI.[Image: Google]But what Google’s design team most wants to highlight is that Material 3 Expressive isn’t style over substance. Validated by 46 studies that tested hundreds of designs across more than 18,000 participants, they found that the expressive end of the Material Design system was preferred across all age groups, though especially Gen Z, which preferred the more maximalist screens 87% of the time.[Image: Google]The team also found that Material 3 Expressive was faster to navigate. Certain actions were spotted up to 4x faster than before. And while older adults are typically slower at finding certain buttons on the screen, the larger buttons inside Material 3 Expressive proved faster to find for everyone—while eliminating the age gap. Google claims older adults can use this design system with the same rapidity of youth. (And who woulda thunk, a big red “send” button would be easier to spot than that old little paper airplane in the corner?)As a design solution, it’s hard to argue with Google’s own validating data or the joy of bringing in more color and motion into the mix. But I’m more interested in Material 3 Expression for what it reveals about this era of design. For the last decade and a half, minimalism has taken over everything from blanded branding to interface (the world of interior design notwithstanding, which has been waffling on the idea for some time). But celebratory expression used to be in! Animations like Apple’s genie effect—which shrunk apps into your taskbar like a genie into the lamp—embodied playfulness before minimalism conquered tech. They were invented way back in 2004 during a more optimistic time in tech, right beside bondi blue iMacs with handles on them. This was the hope of a world that didn’t end after Y2K. Now, screen time debates have been decimated by the For You Page and AI everything, while your Grazas and Manischewtizs of the world prioritize a bit of funk over subdued Swissness. We’re back in expressive times again.

Author(s): Marie Originally published on Towards AI. Hallucinations in Healthcare LLMs: Why They Happen and How to Prevent Them Building Trustworthy Healthcare LLM Systems — Part 1 Image generated by the author using ChatGPT TL;DR LLM hallucinations: AI-generated outputs that sound convincing but contain factual errors or fabricated information — posing serious safety risks in healthcare settings. Three main types of hallucinations: factual errors (recommending antibiotics for viral infections), fabrications (inventing non-existent studies or guidelines), misinterpretations (drawing incorrect conclusions from real data). Root causes of hallucinations: probabilistic generation, training that rewards fluency over factual accuracy, lack of real-time verification, and stale or biased data. Mitigation approaches: Retrieval-Augmented Generation (RAG), domain-specific fine-tuning, advanced prompting, guardrails. This series: build a hallucination-resistant pipeline for infectious disease knowledge, starting with a PubMed Central corpus. Hallucinations in medical LLMs aren’t just bugs — they’re safety risks. This series walks through how to ground healthcare language models in real evidence, starting with infectious diseases. Introduction LLMs (large language models) are changing how we interact with medical knowledge — summarizing research, answering clinical questions, even offering second opinions. But they still hallucinate — and in medicine that’s a safety risk, not a quirk. In medical domains, trust is non-negotiable. A hallucinated answer about infectious disease management (e.g., wrong antibiotic, incorrect diagnostic criteria) can directly impact patient safety, so grounding models in verifiable evidence is mandatory. That’s why this blog series exists. This four-part series will show you how to build a hallucination-resistant workflow, step-by-step: Part 1 (this post): what hallucinations are, why they happen and how to build a domain-specific corpus using open access medical literature Part 2: Turn that corpus into a RAG pipeline Part 3: Add hallucination detection metrics Part 4: Put it all together and build a transparent interface to show users the evidence behind the LLM’s responses What Are Hallucinations in LLMs? Hallucinations are model-generated outputs that sound correct and coherent, but are not factually correct. They sound convincing but are often false, unverifiable or entirely made up. Why They Matter in Healthcare These errors can have serious implications, especially in clinical settings where they might lead to improper treatment recommendations. The wrong recommendation in clinical settings could have life or death consequences, which is why it is critical to mitigate these hallucinations by building transparent, evidence-based systems. Image generated by the author using ChatGPT Main Types of Hallucinations 1. Factual Errors Factual errors happen when LLMs make incorrect claims about verifiable facts. Using our infectious disease example, recommending antibiotics for influenza would be a type of factual error. 2. Fabrications Fabrications involve LLMs inventing non-existent entities or information. In the context of healthcare, for example, these could be fictional research studies, medical guidelines that don’t exist or made-up technical concepts. 3. Misinterpretations Misinterpretation happens when LLMs take real information but misrepresents or mis-contextualizes it. For example, a model might reference a study that exists, but draws the wrong conclusions Why LLMs hallucinate Large language models hallucinate because they don’t truly understand facts like humans do simply predict what words should come next based on patterns they’ve observed in their training data. When these AI systems encounter unfamiliar topics or ambiguous questions, they don’t have the ability to say “I don’t know” and instead generate confident-sounding but potentially incorrect responses. This tendency stems from several factors: Their training prioritizes fluent, human-like text over factual caution They lack real-time access to verified information sources They have no inherent understanding of truth versus fiction. Conflicting information in training data can push the model to average contradictory sources. The problem is compounded by limitations in training data that may contain outdated, biased, or inaccurate information, as well as the fundamental auto-regressive nature of how these models generate text one piece at a time. How Can We Address Hallucinations? There are various methods to mitigate or detect hallucinations. Mitigation Strategies Fine-tuning with Domain-Specific Data: The main reason for hallucination lies in knowledge gaps in the model’s training data. This approach helps by introducing domain specific knowledge and can be very powerful to create models that understand better the specialized medical terminology or various nuances in clinical text. Retrieval-Augmented Generation (RAG): This method allows the integration of external knowledge sources by retrieving relevant information before generating the answer. It helps by grounding the model outputs in verified external sources instead of relying only on the model’s training data. This is the method we will be focusing on in this series Other noteworthy strategies: advanced prompting methods like Chain-of-Thoughts or Few-Shot Learning can help mitigate hallucinations by guiding the model’s answer in the right direction. Rules-based guardrails that screen outputs before they reach users add another safety layer. Hallucination Detection Source-attribution scoring: This method compares the LLM answer to the retrieved documents to detect how much of the answer is grounded in the source. Beyond identifying hallucinations, it also allows to highlight the source behind the LLM answer, which helps building trust and transparency. Semantic Entropy Measurement: This method measures uncertainty about the meaning of generated responses and has been developed specifically to address the risk of hallucinations in critical areas involving patient safety for example Consistency-Based Methods: This method involves a self-consistency check, where hallucinations can be detected by prompting the model multiple times with the same query and comparing the outputs for consistency. Some interesting open-access publications to go a bit further: If you’re interesting in reading recent research on this topic, here’s a few research papers worth reading: Code Walkthrough: Downloading Medical Research from PubMed Central To reduce hallucinations in healthcare LLMs, grounding them in reliable medical literature is critical. Let’s start by building a corpus from one of the best sources available: PubMed Central (PMC). This script helps you automate the retrieval of open-access medical papers, making it easy to bootstrap a dataset tailored to your task (e.g., infectious diseases). Here’s how it works: 1. Setup and Environment import requestsimport xml.etree.ElementTree as ETimport jsonimport os, re, timefrom dotenv import load_dotenvload_dotenv()api_key = os.getenv("NCBI_API_KEY")email = os.getenv("EMAIL")base_url = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/" You’ll need to set your NCBI API key and email in a .env file. You can still call the NCBI API without an API key, but this unlocks higher rate limits and it is free 2. Search PMC Because we are interested in full texts to build our knowledge base, we should only download articles that are open access. To do so, we need to fetch the articles from PMC: # 1. Search PMCsearch_url = f"{base_url}esearch.fcgi"search_params = { "db": "pmc", "term": query, "retmax": max_results, "retmode": "json", "api_key": api_key, "email": email}print("Searching PMC...")search_resp = requests.get(search_url, params=search_params)search_resp.raise_for_status()ids = search_resp.json()["esearchresult"]["idlist"] This code queries PMC with your search terms (for example “infectious diseases”) and returns a list of document identifiers (PMCIDs). 3. Fetch and Parse Articles Now we can fetch the full texts using the PMCIDs: # 2. Batch fetchfetch_url = f"{base_url}efetch.fcgi"for i in range(0, len(ids), batch_size): = ids[i : i + batch_size] batch_ids fetch_params = { "db": "pmc", "id": ",".join(batch_ids), "retmode": "xml", "api_key": api_key, "email": email, } time.sleep(delay) r = requests.get(fetch_url, params=fetch_params) r.raise_for_status() Our response is an XML object, so the final step is to parse it and create a dictionary with the relevant sections: pmcid, title, abstract, full_text, publication_date, authors: root = ET.fromstring(r.content)for idx, article in enumerate(root.findall(".//article")): # Extract article details article_data = { "pmcid": f"PMC{batch_ids[idx]}", "title": "", "abstract": "", "full_text": "", "publication_date": "", "authors": [], } # Extract title title_elem = article.find(".//article-title") if title_elem is not None: article_data["title"] = "".join(title_elem.itertext()).strip() # Extract abstract abstract_parts = article.findall(".//abstract//p") if abstract_parts: article_data["abstract"] = " ".join( "".join(p.itertext()).strip() for p in abstract_parts ) # Extract publication date pub_date = article.find(".//pub-date") if pub_date is not None: year = pub_date.find("year") month = pub_date.find("month") day = pub_date.find("day") date_parts = [] if year is not None: date_parts.append(year.text) if month is not None: date_parts.append(month.text) if day is not None: date_parts.append(day.text) article_data["publication_date"] = "-".join(date_parts) # Extract authors author_elems = article.findall(".//contrib[@contrib-type='author']") for author_elem in author_elems: surname = author_elem.find(".//surname") given_names = author_elem.find(".//given-names") author = {} if surname is not None: author["surname"] = surname.text if given_names is not None: author["given_names"] = given_names.text if author: article_data["authors"].append(author) # Extract full text (combining all paragraphs) body = article.find(".//body") if body is not None: paragraphs = body.findall(".//p") article_data["full_text"] = " ".join( "".join(p.itertext()).strip() for p in paragraphs ) The data can then be saved into a jsonl that will be used in our next step — building our RAG system. Let’s be mindful of licensing restrictions: While open access literature allows anyone to access and read the content, it doesn’t mean the authors agreed to redistribution of their work. While this blog post and its content are intended for personal and educational use, if you decide to use this function to build a dataset that will be redistributed or commercialized, it is important to comply with the article’s license agreement. To do so, let’s define a function that will help us pull the license data from the downloaded article: def detect_cc_license(lic_elem): """ Inspect <license> … </license> for Creative Commons URLs or keywords and return a normalised string such as 'cc-by', 'cc-by-nc', 'cc0', or 'other'. """ if lic_elem is None: return "other" # 1) gather candidate strings: any ext-link href + full text candidates: list[str] = [] for link in lic_elem.findall(".//ext-link[@ext-link-type='uri']"): href = link.get("{http://www.w3.org/1999/xlink}href") or link.get("href") if href: candidates.append(href.lower()) candidates.append("".join(lic_elem.itertext()).lower()) # 2) search for CC patterns for text in candidates: if "creativecommons.org" not in text and "publicdomain" not in text: continue # order matters (most restrictive first) if re.search(r"by[-_]nc[-_]nd", text): return "cc-by-nc-nd" if re.search(r"by[-_]nc[-_]sa", text): return "cc-by-nc-sa" if re.search(r"by[-_]nc", text): return "cc-by-nc" if re.search(r"by[-_]sa", text): return "cc-by-sa" if "/by/" in text: return "cc-by" if "publicdomain/zero" in text or "cc0" in text or "public domain" in text: return "cc0" return "other" Here’s a short breakdown of what the licenses mean: Image uploaded by author Here’s the full function for PubMed download: def download_pmc_articles(query, ): max_results = 100, batch_size = 20, delay = 0.2, allowed_licenses = {"cc-by", "cc-by-sa", "cc0"}, out_file = "pmc_articles.jsonl" base_url = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/" # 1. Search PMC search_url = f"{base_url}esearch.fcgi" search_params = { "db": "pmc", "term": query, "retmax": max_results, "retmode": "json", "api_key": api_key, "email": email } print("Searching PMC...") search_resp = requests.get(search_url, params=search_params) search_resp.raise_for_status() ids = search_resp.json()["esearchresult"]["idlist"] # 2. Batch fetch fetch_url = f"{base_url}efetch.fcgi" skipped, saved = 0, 0 with open(out_file, "w") as f: for i in range(0, len(ids), batch_size): batch_ids = ids[i:i+batch_size] fetch_params = { "db": "pmc", "id": ",".join(batch_ids), "retmode": "xml", "api_key": api_key, "email": email } time.sleep(delay) r = requests.get(fetch_url, params=fetch_params) r.raise_for_status() root = ET.fromstring(r.content) for idx, article in enumerate(root.findall(".//article")): # Check license license = detect_cc_license(article.find(".//license")) if license not in allowed_licenses: skipped += 1 continue # skip disallowed license # Extract article details article_data = { "pmcid": f"PMC{batch_ids[idx]}", "title": "", "abstract": "", "full_text": "", "publication_date": "", "authors": [] } # Extract title title_elem = article.find(".//article-title") if title_elem is not None: article_data["title"] = "".join(title_elem.itertext()).strip() # Extract abstract abstract_parts = article.findall(".//abstract//p") if abstract_parts: article_data["abstract"] = " ".join("".join(p.itertext()).strip() for p in abstract_parts) # Extract publication date pub_date = article.find(".//pub-date") if pub_date is not None: year = pub_date.find("year") month = pub_date.find("month") day = pub_date.find("day") date_parts = [] if year is not None: date_parts.append(year.text) if month is not None: date_parts.append(month.text) if day is not None: date_parts.append(day.text) article_data["publication_date"] = "-".join(date_parts) # Extract authors author_elems = article.findall(".//contrib[@contrib-type='author']") for author_elem in author_elems: surname = author_elem.find(".//surname") given_names = author_elem.find(".//given-names") author = {} if surname is not None: author["surname"] = surname.text if given_names is not None: author["given_names"] = given_names.text if author: article_data["authors"].append(author) # Extract full text (combining all paragraphs) body = article.find(".//body") if body is not None: paragraphs = body.findall(".//p") article_data["full_text"] = " ".join("".join(p.itertext()).strip() for p in paragraphs) f.write(json.dumps(article_data) + "\n") saved += 1 print(f"Saved batch {i//batch_size + 1}") print(f"Downloaded {saved} articles to {out_file}, {skipped} articles removed by license filter") Now you can call your function with your query to create your corpus. For example: # Install packages if neededpip install python-dotenv requestsquery = 'bacterial pneumonia treatment'max_results = 500batch_size = 50download_pmc_articles(query, max_results, batch_size) And that’s it! Now all your articles are saved in a jsonl file and ready to be processed for RAG What’s Next: Preparing the Data for RAG In Part 2, we’ll take the domain-specific corpus you just built and use it to power a Retrieval-Augmented Generation (RAG) system — grounding your LLM in real evidence to reduce hallucinations and improve trust. Join thousands of data leaders on the AI newsletter. Join over 80,000 subscribers and keep up to date with the latest developments in AI. From research to projects and ideas. If you are building an AI startup, an AI-related product, or a service, we invite you to consider becoming a sponsor. Published via Towards AI

There’s something about the devotion to simplicity we see in Scandinavian design. Clean lines and muted tones make it one of the most timeless design styles. But what happens when we infuse that signature calm with some modernism? The Curated Apartment, designed by Yevheniia Dubrovska and Yuliia Olenchyn and photographed by Yevhenii Avramenko, answers that beautifully. In this space, classic Scandi principles are complemented by bold materials and sculptural lighting. Let’s walk through the Curated Apartment and look through it. The living room in the Curated Apartment is rooted in Scandinavian principles. It features a muted palette of soft neutrals, crisp whites, and pale woods. These open up the room to light and air. But what truly elevates the space is the modern twist: sculptural furniture with organic curves, a striking brass chandelier that commands the ceiling, and bold yet balanced pops of color like the sunflower-yellow lounge chair and the teal-accented reading nook.  Each piece feels hand-selected, not for the sake of trend, but for how it contributes to the room’s sense of ease. Layered textures, including the subtly graphic area rug, add just enough dimension to keep things cozy without visual clutter. The kitchen in the Curated Apartment is a visual centerpiece. At first glance, you’re drawn to the exquisite veining of the marble countertops and backsplash. These ripple like fine art across the clean-lined cabinetry. The wood tones offer warmth and natural grounding, while the fluted white upper cabinets add texture. The kitchen transitions into the dining space with a glass-front cabinet, which turns dishware into decor. Whether it’s morning coffee or evening entertaining, this kitchen holds space for both ritual and beauty. The dining nook is effortlessly cozy and light-filled. The round wooden table encourages intimate conversation. The natural linen Roman shades filter in soft daylight. Paired with simple oak chairs and a touch of greenery, this Scandi-style space is designed for slow mornings, shared meals, and everything in between. In this bedroom, the bold, dark-stained headboard anchors the space with a sense of depth. The rest of the room remains airy and open. Light oak chevron floors and a sculptural shelving unit soften the contrast. Details like the matte black mobile chandelier and the wall-mounted globe sconce add a contemporary edge. This bedroom embraces a softer side of minimalism. With layered neutrals, warm wood tones, and gentle lighting, the space feels calm. The sculptural rattan screen and curved pendant bring texture and flow. This bedroom embraces a softer side of minimalism. With layered neutrals, warm wood tones, and gentle lighting, the space feels calm. The sculptural rattan screen and curved pendant bring texture and flow.