A support assistant that answers from your documents, and nothing else.

1. Takes the repeat questionsThe assistant answers the specs, steps, and policy details your team looks up again and again, straight from the document, at any hour it's running.
2. Gives answers people can checkEach answer names its page, so a customer or technician can open the document and confirm it.
3. Shows the pictureAsk how to do something or ask for a diagram, and the assistant shows the pages its answer comes from.
4. Admits what it doesn't knowIf your document doesn't cover a question, the assistant says so. It won't fill the gap with a guess.

Use cases

• Customer questions about a product manual
• Technician help from a service manual
• Staff questions about the employee handbook
• Step-by-step help with procedures (SOPs)
• Policy and compliance lookups
• Training and onboarding material
• Warranty and returns questions
• Installation and setup help
• Safety and handling instructions
• IT help desk answers
• Product catalogue and price lookups
• Guest or tenant information

I tried ten ways to push the assistant off the document, from reworded jailbreaks to "search the internet". It refused all ten and still answered the real questions.

Four checks do this. A relevance score turns away off-topic questions before the model sees them. Strict instructions tell the model to answer only from the passages it gets. A blocklist catches 95 known jailbreak phrases. The page cleans every answer before showing it, so it can't run hidden code.

1. On your serverThe PDF and its search index live on the machine that runs the assistant. With a hosted model, only the question and the five best-matching passages leave it. With a local model, nothing does.
2. Keys kept privateThe API key sits in the server's settings. It never appears in the page or the code.
3. Password if you want onePut the whole chat behind a password when it's for staff or a pilot group.
4. No outside requestsThe chat page loads no scripts, fonts, or trackers from other sites.

1. You send the documentYour PDF, your logo, and a handful of questions your customers or staff ask most.
2. I set it upYour name and logo on the chat page, suggested questions that lead to real answers, and the off-topic filter tuned to your document.
3. I test itYour questions, plus the attack set above, run against your document. You see the results before launch.
4. You launchA chat page you link from your site or share with your team, running on a hosting service or on a computer you own.

The assistant needs a model to write each answer. The model can be a free hosted one, a paid hosted one, or one that runs on your own server. Which one fits comes down to three things: how private your documents are, how many questions you expect each day, and what you want to spend.

• Does it work with scanned PDFs?

  Yes, if the scan has a text layer, which most OCR'd scans do. The test manual was 1,379 scanned pages.

• How fast are the answers?

  In testing on free-tier API plans, answers took about 20 seconds to 2 minutes. Short lookups came back fastest; long procedures took the longest.

• Can I switch model providers later?

  Yes, including to a local model. The search runs on your own server, so a switch only changes which model writes the answers. Your documents and setup carry over.

• Can it read more than one document?

  This version reads one PDF per assistant.

For the technical reader. A small Python server (FastAPI, LangChain, Chroma) and one HTML page. DeepSeek writes the answers, and NVIDIA's reranker picks the passages. To point it at a different document, you swap the PDF and edit one settings file with the name, logo, suggested questions, and relevance cut-off.

1. IndexThe server splits the PDF into passages (2,389 for the manual) and turns them into vectors with a small open model. It builds the index once, in about five minutes for 1,379 pages, and loads it in about ten seconds after that.
2. RetrieveEach question pulls the 20 closest passages. The reranker reads them against the question and keeps the best five.
3. AnswerThe model gets only those five passages, each labelled with its page, plus a prompt that tells it to cite pages and refuse anything the passages don't cover.
4. Show the pageFor diagram and how-to questions, the page shows the scans its answer cites. Refusals show no pictures.

What broke in testing, and the fix

1. "Sorry," with a picture attachedThe model only reads text, so it refused diagram requests while the image code showed pictures anyway. Now each passage carries its page number, the prompt tells the model the app will show the page, and the app shows images only for pages the answer cites.
2. Blank answersDeepSeek thinks before it answers, and it used up the default 1,024-token limit before writing a word. With thinking turned off, one procedure answer went from 201 seconds to 43.
3. Too many picturesEarly answers showed every page the search touched, including pages the answer never used. Now the app reads the page numbers in the answer and shows only those.
4. Scanned textOCR adds typos. The prompt tells the model to read past them but copy specs and part numbers exactly. I also took "emergency" off the blocklist, because it blocked "emergency brake" questions.

Selected code

MIN_RELEVANCE = CONFIG["min_relevance"]  # -4.0 for the test manual

retrieved_docs = qa_chain.retriever.invoke(question.query)
top_score = retrieved_docs[0].metadata.get("relevance_score") if retrieved_docs else None
if not retrieved_docs or (top_score is not None and top_score < MIN_RELEVANCE):
    return {"answer": REFUSAL, "images": []}

cited = {int(n) - 1
         for m in re.finditer(r"pages?\s+([\d,\s and&–-]+)", answer, re.I)
         for n in re.findall(r"\d+", m.group(1))}
pages = (cited & retrieved_pages) or retrieved_pages
refused = REFUSAL.lower().rstrip(".") in answer.lower()
images = extract_images(pages) if (intent_has_visual or context_has_phrase) and not refused else []

class SafeRerank(BaseDocumentCompressor):
    def compress_documents(self, documents, query, callbacks=None):
        try:
            return reranker.compress_documents(documents, query)
        except Exception as e:
            print(f"Reranker unavailable, using plain search order: {e}")
            return list(documents)[:5]