Wie Sie in 20 Minuten einen KI-Bot bauen – mit Produkten von Empolis

Overview / Purpose

• The speakers present a fast onboarding path to Empolis Cloud products: in about 20 minutes, users learn how to:
  • Build an AI chatbot
  • Create guided, structured dialogue flows
  • Extend the system by adding content and documents (including automatic metadata enrichment)
• Core idea: chatbot answers come from the Empolis knowledge base (knowledge articles + FAQ + decision trees) using knowledge-graph metadata filtering and then passing the relevant results to an LLM.

---

Key technical/product workflow: Build an AI chatbot (4 steps)

1. Maintain metadata in the Empolis Knowledge Graph

   • Use the GRA Knowledge Graph Editor to manage entities like:
     • Components
     • Document types
     • Manufacturers
     • Products
   • Create products and variants/subtypes (example: bicycles “Mars,” “Jupiter,” “Neptune”).
   • Add synonyms (e.g., “Mars bicycle,” “Mars bike”).
   • Link components to products (e.g., gears + specific gear system “Pinion P118”).
   • Add rich content fields: descriptions, main/preview images, and component type labels.

2. Create and publish knowledge articles (Expert Knowledge)

   • Go to the Expert Knowledge module (from the Welcome Center).
   • Define a document type (example: “product information”) and the required information units (general info, technical details, highlights, etc.).
   • Create a knowledge article (example: product description for “Neptune / heavy bike”).
   • Support multi-language content:
     • Create content and translate all elements (German/English/French).
   • Add access permissions (who can view the content).
   • Attach knowledge-graph metadata (supplier, product assignment, document type, etc.) after synchronizing metadata via administration.
   • Use an approval workflow before publishing (draft → approval stages → published into the production environment).
     • Notes that multiple approval stages are supported; experts review content.

3. Activate chatbot + configure prompting

   • Enable the chatbot and optionally adjust the prompt:
     • Choose/steer the LLM model (example mentions “GPT,” “entropy/Claude,” “Llama” as options in the UI description).
     • Adjust response behavior via temperature.
     • Define product/component names and response constraints (example: “I’m just an assistant, look in the documents,” and expected actions).
   • The prompting can be imported via an API call.

4. Chat with the system (how answers are grounded)

   • The chatbot can answer product questions using the correct knowledge article (e.g., weight, brakes type).
   • It can also answer FAQ questions (reuses the FAQ knowledge source, including charging-cycle details).
   • It provides:
     • Correct answers (example: “8 kg,” “hydraulic disc brakes”)
     • Ability to jump back to the original knowledge article.

---

“Behind the scenes” explanation (chat grounding logic)

• The system accesses the full Empolis knowledge base from the Expert Knowledge module.
• It can find relevant content using:
  • Decision trees (searched/identified rather than manually traversed)
  • Specific prompts
  • Knowledge-graph concepts/filters defined via metadata and symbolic search
• Pipeline:
  1. User question → search for relevant knowledge articles + apply metadata filters
  2. Send retrieved context to the LLM
  3. LLM returns a response grounded in that retrieved content

---

Guided dialogue tutorial: Expert Dialogue (decision trees)

• Acknowledges that pure LLM conversation is statistically driven and can be hard to reliably optimize.
• Solution: provide structured expert dialogues via decision trees.

Tutorial steps

1. Create a decision tree

   • Use Answer Types:
     • Questions (nodes with multiple answer options to guide the user)
     • Hints (intermediate guidance like safety information)
     • Solutions (end-point actions/steps)
   • Example case: e-bike servicing flow using yes/no structure and conditional branching.
   • Notes:
     • Yes/no options can be created automatically; nodes can be edited with descriptions, images, etc.
     • Ability to enable automatic answers using the knowledge model.
     • Ability to link documents from Expert Knowledge to enrich tree nodes.

2. Translate the tree into multiple languages

   • Use a translation overview and tree settings.
   • Add languages (e.g., English), then auto-translate all nodes.
   • Manually check/edit per language.

3. Publish properly

   • Add/attach metadata so the dialogue is searchable and visible:
     • Visibility/role-based access
     • Metadata links (products like Jupiter/Mars/Neptune, manufacturer like “heavybike,” etc.)
   • Publish to the production environment.
   • Test via the portal/explorer UI and click through the dialogue.

---

Integrating external documents + metadata (document management)

1. Upload content (ZIP ingestion)

   • Use the Document Management module and upload a ZIP file (simple external data entry).
   • Assign labels/names/identifiers and optionally language-specific folder naming.
   • The system processes the archive asynchronously.

2. Search impact after processing

   • After processing, document content becomes searchable alongside manually created articles.
   • Example: searching “pinion…” finds not only articles but also uploaded documents.

3. Manual metadata assignment

   • Users can edit document metadata manually.
   • After metadata changes, the system updates the search index, enabling filtered/relevant search results.

4. Automatic metadata enrichment (Autotagging)

   • Configure autotagging in the Knowledge Graph Editor:
     • Detect components based on document content.
     • Use “keep” logic to avoid overwriting manually set metadata.
     • Define language-independent synonyms (e.g., “p1.18” → “pinion p1.18 …”).
   • Also enable autotagging for document types:
     • Based on file path / directory structure rather than text content.
     • Assign metadata like:
       • “operating instructions” for directories/names containing “instructions”
       • “advertising text” / “order” for directories containing “order/orders”
     • Mentions linguistic expansion (language-specific handling).

5. Publishing model changes triggers retroactive updates

   • After publishing autotagging/model changes, the system checks and applies them across the existing document corpus.
   • Results: previously missing document-type metadata becomes available automatically (instructions, advertising texts, orders), including documents from the ZIP archive.

---

How the onboarding finishes

• Emphasizes limitations of “30 minutes,” pointing to:
  • An onboarding assistant and deeper documentation
  • Step-by-step guides for connecting/synchronizing data sources
  • Extending the knowledge model, importing metadata from multiple sources, and inviting users to test together
• Encourages contacting Empolis for support or to try the system.

---

Main speakers / sources

• Erik Brabener — Chief Product Officer, empolis
• Alexander Ferin — guides the program (co-speaker)
• Kelvin Mutz — guides the program (co-speaker)

Empolis Cloud modules referenced

• Knowledge Graph Editor (GRA)
• Expert Knowledge
• Expert Dialogue
• Document Management
• Administration
• Production environment/portal