Intelligente Wissensdatenbank : Unternehmenswissen zentralisieren

In jedem Unternehmen ist Wissen verstreut: Confluence-Dokumente, Google Drive, E‑Mails, Expertise im Kopf der Mitarbeitenden. Eine intelligente Wissensdatenbank, angetrieben durch RAG, verwandelt dieses Chaos in einen Assistenten, der sofort auf jede fachliche Frage antworten kann.

Das Problem des verstreuten Wissens

Die Realität in Unternehmen

Eine Studie von McKinsey zeigt, dass ein Mitarbeiter im Schnitt 1,8 Stunden pro Tag mit der Suche nach Informationen verbringt. Das sind 9,3 Stunden pro Woche bzw. 23% der Arbeitszeit, die mit Suchen verloren gehen.

Typische Symptome:

• "Wo ist das Dokument zur Prozedur X?"
• "Wer weiß, wie man Y konfiguriert?"
• "Wir hatten dieses Problem schon gelöst, aber ich finde die Lösung nicht mehr"
• "Ich bin neu und weiß nicht, wo ich suchen soll"

Grenzen traditioneller Lösungen

Der Vorteil einer KB RAG

Eine RAG-Wissensdatenbank ermöglicht:

• Semantische Suche : Informationen finden, auch ohne die exakten Begriffe zu kennen
• Synthese : Konsolidierte Antwort aus mehreren Quellen erhalten
• Kontextualisierung : Antworten, angepasst ans Nutzerprofil
• Kontinuierliche Aktualisierung : Automatische Synchronisation mit den Quellen
• Kapitalisierung : Jede Antwort bereichert die Basis

Architektur einer intelligenten KB

┌─────────────────────────────────────────────────────────────┐
│                    SOURCES DE DONNÉES                        │
├──────────┬──────────┬──────────┬──────────┬────────────────┤
│Confluence│  Google  │  Notion  │  Slack   │   Documents    │
│          │  Drive   │          │(archivé) │     PDF        │
└────┬─────┴────┬─────┴────┬─────┴────┬─────┴───────┬────────┘
     │          │          │          │             │
     └──────────┴──────────┴──────────┴─────────────┘
                           │
                           ▼
              ┌─────────────────────────┐
              │   Ingestion Pipeline    │
              │  - Extraction texte     │
              │  - Chunking intelligent │
              │  - Métadonnées          │
              └───────────┬─────────────┘
                          ▼
              ┌─────────────────────────┐
              │     Embedding +         │
              │     Indexation          │
              └───────────┬─────────────┘
                          ▼
              ┌─────────────────────────┐
              │    Base Vectorielle     │
              │      (Qdrant)           │
              └───────────┬─────────────┘
                          │
┌─────────────────────────┴──────────────────────────────────┐
│                       INTERFACE                             │
├─────────────┬─────────────┬─────────────┬─────────────────┤
│  Chatbot    │    Slack    │    API      │   Recherche     │
│    Web      │    Bot      │   interne   │   Avancée       │
└─────────────┴─────────────┴─────────────┴─────────────────┘

Source-Connectoren

Confluence-Connector

DEVELOPERpython
from atlassian import Confluence
import html2text

class ConfluenceConnector:
    def __init__(self, url: str, username: str, api_token: str):
        self.confluence = Confluence(
            url=url,
            username=username,
            password=api_token,
            cloud=True
        )
        self.html_converter = html2text.HTML2Text()
        self.html_converter.ignore_links = False

    def get_all_pages(self, space_keys: list[str] = None) -> list[dict]:
        """
        Ruft alle Seiten der angegebenen Spaces ab
        """
        documents = []

        if space_keys is None:
            spaces = self.confluence.get_all_spaces()
            space_keys = [s['key'] for s in spaces['results']]

        for space_key in space_keys:
            pages = self._get_space_pages(space_key)
            documents.extend(pages)

        return documents

    def _get_space_pages(self, space_key: str) -> list[dict]:
        """
        Ruft alle Seiten eines Space ab
        """
        pages = []
        start = 0
        limit = 50

        while True:
            result = self.confluence.get_all_pages_from_space(
                space_key,
                start=start,
                limit=limit,
                expand='body.storage,ancestors,version'
            )

            for page in result:
                pages.append(self._format_page(page, space_key))

            if len(result) < limit:
                break
            start += limit

        return pages

    def _format_page(self, page: dict, space_key: str) -> dict:
        """
        Formatiert eine Confluence-Seite für das RAG
        """
        # HTML in Text umwandeln
        html_content = page.get('body', {}).get('storage', {}).get('value', '')
        text_content = self.html_converter.handle(html_content)

        # Hierarchischen Pfad erstellen
        ancestors = page.get('ancestors', [])
        path = ' > '.join([a['title'] for a in ancestors] + [page['title']])

        return {
            "id": f"confluence_{page['id']}",
            "title": page['title'],
            "content": f"# {page['title']}\n\n{text_content}",
            "metadata": {
                "type": "confluence",
                "source": "confluence",
                "space": space_key,
                "page_id": page['id'],
                "path": path,
                "url": f"{self.confluence.url}/wiki/spaces/{space_key}/pages/{page['id']}",
                "author": page.get('version', {}).get('by', {}).get('displayName'),
                "last_updated": page.get('version', {}).get('when'),
                "version": page.get('version', {}).get('number')
            }
        }

Google Drive-Connector

DEVELOPERpython
from google.oauth2 import service_account
from googleapiclient.discovery import build
from googleapiclient.http import MediaIoBaseDownload
import io

class GoogleDriveConnector:
    def __init__(self, credentials_path: str, folder_ids: list[str] = None):
        credentials = service_account.Credentials.from_service_account_file(
            credentials_path,
            scopes=['https://www.googleapis.com/auth/drive.readonly']
        )
        self.service = build('drive', 'v3', credentials=credentials)
        self.folder_ids = folder_ids or ['root']

    def get_all_documents(self) -> list[dict]:
        """
        Ruft alle Dokumente aus den angegebenen Ordnern ab
        """
        documents = []

        for folder_id in self.folder_ids:
            docs = self._get_folder_documents(folder_id)
            documents.extend(docs)

        return documents

    def _get_folder_documents(self, folder_id: str, path: str = "") -> list[dict]:
        """
        Ruft rekursiv die Dokumente eines Ordners ab
        """
        documents = []

        # Dateien auflisten
        query = f"'{folder_id}' in parents and trashed = false"
        results = self.service.files().list(
            q=query,
            fields="files(id, name, mimeType, modifiedTime, owners, webViewLink)",
            pageSize=100
        ).execute()

        for file in results.get('files', []):
            current_path = f"{path}/{file['name']}" if path else file['name']

            if file['mimeType'] == 'application/vnd.google-apps.folder':
                # Rekursion in Unterordnern
                sub_docs = self._get_folder_documents(file['id'], current_path)
                documents.extend(sub_docs)
            else:
                # Inhalt der Datei extrahieren
                content = self._extract_content(file)
                if content:
                    documents.append({
                        "id": f"gdrive_{file['id']}",
                        "title": file['name'],
                        "content": content,
                        "metadata": {
                            "type": "google_drive",
                            "source": "google_drive",
                            "file_id": file['id'],
                            "path": current_path,
                            "mime_type": file['mimeType'],
                            "url": file.get('webViewLink'),
                            "author": file.get('owners', [{}])[0].get('displayName'),
                            "last_updated": file.get('modifiedTime')
                        }
                    })

        return documents

    def _extract_content(self, file: dict) -> str:
        """
        Extrahiert den Textinhalt einer Datei
        """
        mime_type = file['mimeType']
        file_id = file['id']

        # Google Docs - als Text exportieren
        if mime_type == 'application/vnd.google-apps.document':
            return self._export_google_doc(file_id)

        # Google Sheets - als CSV exportieren
        elif mime_type == 'application/vnd.google-apps.spreadsheet':
            return self._export_google_sheet(file_id)

        # PDF - herunterladen und extrahieren
        elif mime_type == 'application/pdf':
            return self._extract_pdf(file_id)

        # Textdateien
        elif mime_type.startswith('text/'):
            return self._download_text_file(file_id)

        return None

    def _export_google_doc(self, file_id: str) -> str:
        """
        Exportiert ein Google Doc als Text
        """
        request = self.service.files().export_media(
            fileId=file_id,
            mimeType='text/plain'
        )
        content = io.BytesIO()
        downloader = MediaIoBaseDownload(content, request)

        done = False
        while not done:
            _, done = downloader.next_chunk()

        return content.getvalue().decode('utf-8')

Notion-Connector

DEVELOPERpython
from notion_client import Client

class NotionConnector:
    def __init__(self, token: str, database_ids: list[str] = None):
        self.client = Client(auth=token)
        self.database_ids = database_ids

    def get_all_pages(self) -> list[dict]:
        """
        Ruft alle Notion-Seiten ab
        """
        documents = []

        if self.database_ids:
            for db_id in self.database_ids:
                pages = self._get_database_pages(db_id)
                documents.extend(pages)
        else:
            # Alle zugänglichen Seiten durchsuchen
            results = self.client.search(filter={"property": "object", "value": "page"})
            for page in results['results']:
                doc = self._format_page(page)
                if doc:
                    documents.append(doc)

        return documents

    def _get_database_pages(self, database_id: str) -> list[dict]:
        """
        Ruft die Seiten einer Notion-Database ab
        """
        documents = []
        has_more = True
        start_cursor = None

        while has_more:
            response = self.client.databases.query(
                database_id=database_id,
                start_cursor=start_cursor
            )

            for page in response['results']:
                doc = self._format_page(page)
                if doc:
                    documents.append(doc)

            has_more = response['has_more']
            start_cursor = response.get('next_cursor')

        return documents

    def _format_page(self, page: dict) -> dict:
        """
        Formatiert eine Notion-Seite für das RAG
        """
        # Titel extrahieren
        title = self._extract_title(page)
        if not title:
            return None

        # Inhalt extrahieren
        content = self._extract_page_content(page['id'])

        return {
            "id": f"notion_{page['id']}",
            "title": title,
            "content": f"# {title}\n\n{content}",
            "metadata": {
                "type": "notion",
                "source": "notion",
                "page_id": page['id'],
                "url": page['url'],
                "created_time": page['created_time'],
                "last_updated": page['last_edited_time']
            }
        }

    def _extract_page_content(self, page_id: str) -> str:
        """
        Extrahiert den Textinhalt einer Notion-Seite
        """
        blocks = self.client.blocks.children.list(block_id=page_id)
        content_parts = []

        for block in blocks['results']:
            text = self._block_to_text(block)
            if text:
                content_parts.append(text)

        return "\n\n".join(content_parts)

    def _block_to_text(self, block: dict) -> str:
        """
        Konvertiert einen Notion-Block in Text
        """
        block_type = block['type']

        if block_type == 'paragraph':
            return self._rich_text_to_string(block['paragraph']['rich_text'])

        elif block_type in ['heading_1', 'heading_2', 'heading_3']:
            prefix = '#' * int(block_type[-1])
            text = self._rich_text_to_string(block[block_type]['rich_text'])
            return f"{prefix} {text}"

        elif block_type == 'bulleted_list_item':
            return f"- {self._rich_text_to_string(block['bulleted_list_item']['rich_text'])}"

        elif block_type == 'numbered_list_item':
            return f"1. {self._rich_text_to_string(block['numbered_list_item']['rich_text'])}"

        elif block_type == 'code':
            code = self._rich_text_to_string(block['code']['rich_text'])
            lang = block['code'].get('language', '')
            return f"```{lang}\n{code}\n```"

        return ""

    def _rich_text_to_string(self, rich_text: list) -> str:
        return "".join([rt['plain_text'] for rt in rich_text])

Intelligente Ingestion-Pipeline

Adaptives Chunking nach Dokumenttyp

DEVELOPERpython
from langchain.text_splitter import (
    RecursiveCharacterTextSplitter,
    MarkdownTextSplitter,
    Language
)

class AdaptiveChunker:
    def __init__(self):
        self.chunkers = {
            "markdown": MarkdownTextSplitter(
                chunk_size=1000,
                chunk_overlap=100
            ),
            "code": RecursiveCharacterTextSplitter.from_language(
                language=Language.PYTHON,
                chunk_size=500,
                chunk_overlap=50
            ),
            "prose": RecursiveCharacterTextSplitter(
                chunk_size=800,
                chunk_overlap=100,
                separators=["\n\n", "\n", ". ", " ", ""]
            ),
            "faq": RecursiveCharacterTextSplitter(
                chunk_size=400,
                chunk_overlap=0,
                separators=["Q:", "Question:", "---"]
            )
        }

    def chunk(self, document: dict) -> list[dict]:
        """
        Zerlegt ein Dokument mit der passenden Strategie
        """
        doc_type = self._detect_type(document)
        chunker = self.chunkers.get(doc_type, self.chunkers["prose"])

        chunks = chunker.split_text(document["content"])

        return [
            {
                "id": f"{document['id']}_chunk_{i}",
                "content": chunk,
                "metadata": {
                    **document["metadata"],
                    "parent_id": document["id"],
                    "parent_title": document["title"],
                    "chunk_index": i,
                    "total_chunks": len(chunks)
                }
            }
            for i, chunk in enumerate(chunks)
        ]

    def _detect_type(self, document: dict) -> str:
        """
        Ermittelt den Dokumenttyp, um das chunking anzupassen
        """
        content = document["content"]
        title = document["title"].lower()

        # FAQ
        if any(kw in title for kw in ["faq", "questions", "q&a"]):
            return "faq"

        # Code
        code_indicators = ["```", "def ", "class ", "function ", "import "]
        if sum(1 for ind in code_indicators if ind in content) >= 2:
            return "code"

        # Strukturiertes Markdown
        if content.count("#") >= 3 or content.count("##") >= 2:
            return "markdown"

        return "prose"

Anreicherung der Metadaten

DEVELOPERpython
class MetadataEnricher:
    def __init__(self, llm=None):
        self.llm = llm

    async def enrich(self, document: dict) -> dict:
        """
        Bereichert die Metadaten eines Dokuments
        """
        enriched = document.copy()

        # Automatische Kategorisierung
        enriched["metadata"]["category"] = await self._categorize(document)

        # Entitätsextraktion
        enriched["metadata"]["entities"] = await self._extract_entities(document)

        # Qualitäts-Score
        enriched["metadata"]["quality_score"] = self._calculate_quality(document)

        # Automatische Tags
        enriched["metadata"]["auto_tags"] = await self._generate_tags(document)

        return enriched

    async def _categorize(self, document: dict) -> str:
        """
        Kategorisiert das Dokument automatisch
        """
        if not self.llm:
            return "uncategorized"

        prompt = f"""
        Catégorise ce document parmi les catégories suivantes :
        - procedure : Procédure ou guide étape par étape
        - reference : Documentation de référence technique
        - policy : Politique d'entreprise ou règlement
        - tutorial : Tutoriel ou formation
        - faq : Questions fréquentes
        - other : Autre

        Titre : {document['title']}
        Début du contenu : {document['content'][:500]}

        Réponds uniquement avec le nom de la catégorie.
        """

        response = await self.llm.generate(prompt, temperature=0)
        return response.strip().lower()

    async def _extract_entities(self, document: dict) -> dict:
        """
        Extrahiert benannte Entitäten
        """
        # Einfache Extraktion per Regex
        import re

        content = document["content"]

        return {
            "tools": re.findall(r'\b(?:Jira|Confluence|Slack|GitHub|GitLab|AWS|Azure|GCP)\b', content, re.I),
            "teams": re.findall(r'équipe\s+(\w+)', content, re.I),
            "people": [],  # Benötigt fortgeschrittenes NER
            "versions": re.findall(r'v?\d+\.\d+(?:\.\d+)?', content)
        }

    def _calculate_quality(self, document: dict) -> float:
        """
        Berechnet einen Qualitäts-Score für das Dokument
        """
        score = 1.0
        content = document["content"]

        # Abzüge
        if len(content) < 100:
            score -= 0.3  # Zu kurz
        if "TODO" in content or "WIP" in content:
            score -= 0.2  # Nicht finalisiert
        if document["metadata"].get("last_updated"):
            # Altes Dokument
            from datetime import datetime, timedelta
            try:
                updated = datetime.fromisoformat(document["metadata"]["last_updated"].replace("Z", "+00:00"))
                if datetime.now(updated.tzinfo) - updated > timedelta(days=365):
                    score -= 0.2
            except:
                pass

        # Boni
        if content.count("#") >= 2:
            score += 0.1  # Gut strukturiert
        if "exemple" in content.lower() or "example" in content.lower():
            score += 0.1  # Enthält Beispiele

        return max(0, min(1, score))

    async def _generate_tags(self, document: dict) -> list[str]:
        """
        Generiert automatische Tags
        """
        if not self.llm:
            return []

        prompt = f"""
        Génère 3 à 5 tags pertinents pour ce document.

        Titre : {document['title']}
        Contenu : {document['content'][:1000]}

        Réponds avec les tags séparés par des virgules.
        """

        response = await self.llm.generate(prompt, temperature=0.3)
        tags = [t.strip().lower() for t in response.split(",")]
        return tags[:5]

Intelligente Suche

Hybride Suche mit Personalisierung

DEVELOPERpython
class KBSearch:
    def __init__(self, vector_db, bm25_index, user_service):
        self.vector_db = vector_db
        self.bm25_index = bm25_index
        self.user_service = user_service

    async def search(
        self,
        query: str,
        user_id: str,
        top_k: int = 10,
        filters: dict = None
    ) -> list[dict]:
        """
        Personalisierte hybride Suche
        """
        # Nutzerprofil zur Personalisierung
        user_profile = await self.user_service.get_profile(user_id)

        # Vektorielle Suche
        vector_results = await self._vector_search(query, top_k * 2, filters)

        # Lexikalische BM25-Suche
        bm25_results = await self._bm25_search(query, top_k * 2, filters)

        # RRF-Fusion (Reciprocal Rank Fusion)
        fused = self._rrf_fusion(vector_results, bm25_results)

        # Personalisierung basierend auf Profil
        personalized = self._personalize(fused, user_profile)

        return personalized[:top_k]

    def _rrf_fusion(
        self,
        results_1: list[dict],
        results_2: list[dict],
        k: int = 60
    ) -> list[dict]:
        """
        RRF-Fusion zweier Ergebnislisten
        """
        scores = {}

        for rank, doc in enumerate(results_1):
            doc_id = doc["id"]
            scores[doc_id] = scores.get(doc_id, 0) + 1 / (k + rank + 1)

        for rank, doc in enumerate(results_2):
            doc_id = doc["id"]
            scores[doc_id] = scores.get(doc_id, 0) + 1 / (k + rank + 1)

        # Fusionierte Liste erzeugen
        all_docs = {d["id"]: d for d in results_1 + results_2}
        sorted_ids = sorted(scores.keys(), key=lambda x: scores[x], reverse=True)

        return [
            {**all_docs[doc_id], "fusion_score": scores[doc_id]}
            for doc_id in sorted_ids
            if doc_id in all_docs
        ]

    def _personalize(self, results: list[dict], user_profile: dict) -> list[dict]:
        """
        Personalisiert die Ergebnisse entsprechend dem Nutzerprofil
        """
        user_team = user_profile.get("team")
        user_role = user_profile.get("role")
        user_history = set(user_profile.get("viewed_docs", []))

        for result in results:
            boost = 0

            # Boost für Dokumente des eigenen Teams
            if result["metadata"].get("team") == user_team:
                boost += 0.1

            # Boost für Dokumente auf passendem Level
            if result["metadata"].get("target_role") == user_role:
                boost += 0.05

            # Leichter Abzug für bereits gesehene Dokumente (Discovery fördern)
            if result["id"] in user_history:
                boost -= 0.02

            result["personalized_score"] = result.get("fusion_score", 0.5) + boost

        # Neu sortieren nach personalisiertem Score
        return sorted(results, key=lambda x: x["personalized_score"], reverse=True)

Intelligente Vorschläge

DEVELOPERpython
class KBSuggestions:
    def __init__(self, search, analytics):
        self.search = search
        self.analytics = analytics

    async def get_suggestions(self, user_id: str, context: str = None) -> list[dict]:
        """
        Generiert personalisierte Vorschläge
        """
        suggestions = []

        # 1. Beliebte Dokumente
        popular = await self._get_popular_docs()
        suggestions.extend([{"type": "popular", **d} for d in popular[:3]])

        # 2. Kürzlich aktualisierte Dokumente
        recent = await self._get_recently_updated()
        suggestions.extend([{"type": "updated", **d} for d in recent[:3]])

        # 3. Basierend auf Nutzerhistorie
        if user_id:
            related = await self._get_related_to_history(user_id)
            suggestions.extend([{"type": "for_you", **d} for d in related[:3]])

        # 4. Basierend auf aktuellem Kontext (Seite, Projekt, etc.)
        if context:
            contextual = await self.search.search(context, user_id, top_k=3)
            suggestions.extend([{"type": "contextual", **d} for d in contextual])

        # Duplikate entfernen
        seen = set()
        unique_suggestions = []
        for s in suggestions:
            if s["id"] not in seen:
                seen.add(s["id"])
                unique_suggestions.append(s)

        return unique_suggestions[:10]

    async def _get_popular_docs(self) -> list[dict]:
        """
        Am meisten aufgerufene Dokumente
        """
        return await self.analytics.get_top_documents(period_days=30, limit=5)

    async def _get_recently_updated(self) -> list[dict]:
        """
        Kürzlich aktualisierte Dokumente
        """
        return await self.search.vector_db.query(
            sort_by="metadata.last_updated",
            sort_order="desc",
            limit=5
        )

System-Prompt für interne KB

DEVELOPERpython
KB_ASSISTANT_PROMPT = """Tu es l'assistant de la base de connaissances de {company_name}.

CONTEXTE UTILISATEUR :
- Nom : {user_name}
- Équipe : {user_team}
- Rôle : {user_role}

RÈGLES :
1. Réponds UNIQUEMENT à partir de la documentation fournie
2. Si l'info n'est pas disponible, dis-le clairement et suggère qui contacter
3. Cite toujours tes sources avec les liens vers les documents
4. Adapte ton niveau technique au rôle de l'utilisateur

FORMAT DE RÉPONSE :
- Commence par une réponse directe et concise
- Détaille ensuite si nécessaire
- Termine par les sources utilisées

DOCUMENTS DISPONIBLES :
{context}

QUESTION :
{question}
"""

Berechtigungsverwaltung

DEVELOPERpython
class KBPermissions:
    def __init__(self, user_service, document_service):
        self.user_service = user_service
        self.document_service = document_service

    async def filter_accessible(
        self,
        documents: list[dict],
        user_id: str
    ) -> list[dict]:
        """
        Filtert Dokumente entsprechend der Berechtigungen des Nutzers
        """
        user = await self.user_service.get_user(user_id)
        user_groups = set(user.get("groups", []))
        user_team = user.get("team")

        accessible = []
        for doc in documents:
            if self._can_access(doc, user_groups, user_team):
                accessible.append(doc)

        return accessible

    def _can_access(
        self,
        document: dict,
        user_groups: set,
        user_team: str
    ) -> bool:
        """
        Prüft, ob ein Nutzer auf ein Dokument zugreifen darf
        """
        doc_meta = document.get("metadata", {})

        # Öffentliche Dokumente
        if doc_meta.get("visibility") == "public":
            return True

        # Team-Dokumente
        if doc_meta.get("visibility") == "team":
            return doc_meta.get("team") == user_team

        # Auf bestimmte Gruppen beschränkte Dokumente
        allowed_groups = set(doc_meta.get("allowed_groups", []))
        if allowed_groups and not allowed_groups.intersection(user_groups):
            return False

        return True

Metriken und Analytics

DEVELOPERpython
class KBAnalytics:
    def __init__(self, db):
        self.db = db

    def track_search(
        self,
        user_id: str,
        query: str,
        results_count: int,
        clicked_doc_id: str = None
    ):
        """
        Protokolliert eine Suche
        """
        self.db.insert("kb_searches", {
            "user_id": user_id,
            "query": query,
            "results_count": results_count,
            "clicked_doc_id": clicked_doc_id,
            "timestamp": datetime.now()
        })

    def get_search_metrics(self, period_days: int = 30) -> dict:
        """
        Suchmetriken
        """
        return {
            "total_searches": self._count_searches(period_days),
            "unique_users": self._count_unique_searchers(period_days),
            "avg_results_per_search": self._avg_results(period_days),
            "zero_result_rate": self._zero_result_rate(period_days),
            "click_through_rate": self._ctr(period_days),
            "top_queries": self._top_queries(period_days),
            "top_documents": self._top_documents(period_days)
        }

    def identify_gaps(self) -> list[dict]:
        """
        Identifiziert Lücken in der KB (Anfragen ohne Ergebnis)
        """
        return self.db.query("""
            SELECT query, COUNT(*) as count
            FROM kb_searches
            WHERE results_count = 0
            AND timestamp > NOW() - INTERVAL '30 days'
            GROUP BY query
            ORDER BY count DESC
            LIMIT 20
        """)

Best Practices

1. Aktualität sicherstellen

• Tägliche automatische Synchronisation
• Alerts für veraltete Dokumente (> 6 Monate ohne Update)
• Regelmäßige Review der am wenigsten aufgerufenen Dokumente

2. Beiträge fördern

• Einfache Oberfläche zum Melden von Fehlern
• Vorschlag zur Aktualisierung nach dem Lesen
• Gamification : Badges für Contributor

3. Adoption messen

Weiterführende Links

• Fondamentaux du Retrieval - Suchoptimierung
• RAG Multimodal - Bilder und PDFs indexieren
• Introduction au RAG - Grundlagen verstehen

Stellen Sie Ihre intelligente KB mit Ailog bereit

Eine RAG-Wissensdatenbank erfordert die Integration vieler Quellen und das Handling komplexer Berechtigungen. Mit Ailog vereinfachen Sie das Deployment:

• Native Connectoren : Confluence, Notion, Google Drive, SharePoint
• Echtzeit-Synchronisation automatisch
• Berechtigungsmanagement integriert (SSO, Gruppen, Teams)
• Anpassbare Suchoberfläche
• Analytics zur Messung der Adoption und Identifikation von Lücken
• Hosting in France konform mit RGPD

Testez Ailog gratuitement und zentralisieren Sie das Wissen Ihres Unternehmens in wenigen Tagen.