Vorwort

In den letzten zwei Jahren hat sich die Technologie der Retrieval-Augmented Generation (RAG, Retrieval-Augmented Generation) allmählich zu einem Kernbestandteil der erweiterten Intelligenz entwickelt. Durch die Kombination der dualen Fähigkeiten von Retrieval und Generierung kann RAG externes Wissen einbringen und bietet so mehr Möglichkeiten für die Anwendung großer Modelle in komplexen Szenarien. In praktischen Landungsszenarien gibt es jedoch oft Probleme wie geringe Abrufgenauigkeit, Störgeräusche, Integrität des Abrufs und unzureichende Professionalität, was zu ernsthaften LLM-Illusionen führt. In diesem Beitrag werden wir uns auf die Details der Wissensverarbeitung und des Abrufs von RAG in realen Landungsszenarien konzentrieren, wie man die RAG-Pineline-Verbindung optimiert und letztendlich die Abrufgenauigkeit verbessert.

Es ist einfach, eine RAG Smart Q&A App schnell zu erstellen, aber sie in einem realen Geschäftsszenario einzusetzen, erfordert eine Menge Vorbereitung.

1.RAG-Schlüsselprozess Quellcode-Interpretation

ZentrumWissensverarbeitungim Gesang antwortenRAGEinige der wichtigsten Prozesse:

1. die Verarbeitung von Wissen

Laden von Wissen -> Wissenszerlegung -> Informationsextraktion -> Wissensverarbeitung (Einbettung/Graph/Schlüsselwörter) -> Wissensspeicherung

• Laden von Wissen

# Wissensfabrik zur Instanziierung
KnowledgeFactory -> create() -> load() -> Dokument
- Wissen
- Markdown
- pdf
- docx
- txt
- html
- pptx
- url
- ...

Wie man expandiert:

from abc import ABC
from typing import List, Any

class Knowledge(ABC): def load(self) -> Liste[Dokument].
def load(self) -> Liste[Dokument].
"""Wissen aus Datenlader laden."""""
"""Wissen aus dem Data Loader laden.""

@classmethod
def document_type(cls) -> Any.
"""Dokumenttyp holen.""""
pass @classmethod def document_type(cls) -> Any.

@classmethod
def support_chunk_strategy(cls) -> List[ChunkStrategy].
"""Unterstützte Chunk-Strategie zurückgeben.""""
return [
ChunkStrategy.CHUNK_BY_SIZE,
ChunkStrategy.CHUNK_BY_PAGE, """ return [ ChunkStrategy.CHUNK_BY_SIZE, ChunkStrategy.
ChunkStrategy.CHUNK_BY_PARAGRAPH, ChunkStrategy.
ChunkStrategy.CHUNK_BY_MARKDOWN_HEADER, ChunkStrategy.
ChunkStrategy.CHUNK_BY_SEPARATOR,
ChunkStrategy.CHUNK_BY_SEPARATOR, ]

@classmethod
def default_chunk_strategy(cls) -> ChunkStrategy.
"""
Rückgabe der Standard-Chunk-Strategie.

Rückgabe.
ChunkStrategy: Standard-Chunk-Strategie.
"""
return ChunkStrategy.CHUNK_BY_SIZE

• Wissensschnipsel

ChunkManager: Leitet die geladenen Wissensdaten an den entsprechenden Chunk-Prozessor zur Zuweisung auf der Grundlage der vom Benutzer festgelegten Chunking-Politik und Chunking-Parameter weiter.

class ChunkManager.
"""Manager für Chunks.""""

def __init__(
self.
knowledge: Knowledge, chunk_parameter.
chunk_parameter: Optional[ChunkParameter] = None,
extractor: Optional[Extractor] = None,
).
"""
Erstellt einen neuen ChunkManager mit dem angegebenen Wissen.

Args: knowledge: (Knowledge) Wissensdatenquelle.
chunk_parameter: (Optional[ChunkParameters]) Chunk-Parameter.
chunk_parameter: (Optional[ChunkParameters]) Chunk-Parameter.
extractor: (Optional[Extractor]) Der für die Zusammenfassung zu verwendende Extraktor.
"""
self._knowledge = Wissen
self._extractor = extractor
self._chunk_parameters = chunk_parameter oder ChunkParameters()
self._chunk_strategy = (
chunk_parameter.chunk_strategy
wenn chunk_parameter und chunk_parameter.chunk_strategy
sonst self._knowledge.default_chunk_strategy().name
)
self._text_splitter = self._chunk_parameters.text_splitter
self._splitter_type = self._chunk_parameters.splitter_type

Erweiterung: Wenn Sie eine neue Slicing-Strategie in der Schnittstelle anpassen wollen

• Neue Slicing-Strategie
• Neue Splitter-Implementierungslogik

class ChunkStrategy(Enum).
"""Chunk Strategie Enum.""""

CHUNK_BY_SIZE: _STRATEGY_ENUM_TYPE = (
RecursiveCharacterTextSplitter, """RecursiveCharacterTextSplitter, """Chunk Strategy Enum.""
[
{
"param_name": "chunk_size",
"param_type": "int",
"default_value": 512, "description": "Die Größe des Datenchunks".
"description": "Die Größe der Datenchunks, die bei der Verarbeitung verwendet werden.",
},
{
"param_name": "chunk_overlap", "param_type": "int": "chunk_type": "chunk_overlap", {
"param_type": "int", "default_value": 50
"standard_wert": 50,
"description": "Der Grad der Überlappung zwischen benachbarten Datenpaketen", }
}
], "chunk size".

"Dokument nach Stückchengröße aufteilen", ), "chunk_value": 50
)

CHUNK_BY_PAGE: _STRATEGY_ENUM_TYPE = (
PageTextSplitter, _STRATEGY_ENUM_TYPE = (
[].
"Seite".
"Dokument nach Seiten aufteilen",
)

CHUNK_BY_PARAGRAPH: _STRATEGY_ENUM_TYPE = (
ParagraphTextSplitter, [
[
{
"param_name": "trennzeichen",
"param_type": "string",
"default_value": "\n", "description": "Absatz", "\n", "\n", "\n", "\n", "\n", "\n", "\n".
"Beschreibung": "Absatztrenner",
}
], "paragraph", "description": "Absatztrenner", }
"paragraph", "split document by paragraph", "description".
"Dokument nach Absatz aufteilen".
)

CHUNK_BY_SEPARATOR: _STRATEGY_ENUM_TYPE = (
SeparatorTextSplitter, [
[
{
"param_name": "trennzeichen",
"param_type": "string",


},
{
"param_name": "enable_merge", "param_type": "parameter_type", }, {
"param_type": "boolean", "default_value": false
"default_value": False,
"description": (
"Ob gemäß der chunk_size zusammengeführt werden soll, nachdem "
"Aufteilung durch den Separator".
),
}
], "trennzeichen", " "Aufteilung durch das Trennzeichen", }, }
"Trennzeichen", "Dokument nach Trennzeichen aufteilen",
"Dokument nach Trennzeichen aufteilen".
)

CHUNK_BY_MARKDOWN_HEADER: _STRATEGY_ENUM_TYPE = (
MarkdownHeaderTextSplitter,
[],
"markdown header",
"Dokument nach Markdown-Header aufteilen",
)

• Extraktion von Wissen
• Vektorextraktion -> Einbettung, ImplementierungEinbettungenStecker

@abstrakteMethode
def embed_documents(self, texts: List[str]) -> List[List[float]].
"""Suchdokumente einbetten.""""

@abstractmethod
def embed_query(self, text: str) -> List[float]].
"""Abfragetext einbetten.""""

async def aembed_documents(self, texts: List[str]) -> List[List[float]].
"""Asynchrone Suche einbetten docs."""""
return await asyncio.get_running_loop().run_in_executor(
None, self.embed_documents, Texte
)

async def aembed_query(self, text: str) -> List[float].
"""Asynchrone Einbettungsabfrage text.""""
return await asyncio.get_running_loop().run_in_executor(
None, self.embed_query, text
)

# EMBEDDING_MODEL=proxy_openai
# proxy_openai_proxy_server_url=https://api.openai.com/v1
# proxy_openai_proxy_api_key={Ihr-openai-sk}
# proxy_openai_proxy_backend=text-embedding-ada-002

## qwen Einbettungsmodell, siehe dbgpt/model/parameter.py
# EMBEDDING_MODEL=proxy_tongyi
# proxy_tongyi_proxy_backend=text-embedding-v1
# proxy_tongyi_proxy_api_key={Ihr-api-key}

## qianfan Einbettungsmodell, siehe dbgpt/model/parameter.py
# EMBEDDING_MODEL=proxy_qianfan
# proxy_qianfan_proxy_backend=bge-large-zh
# proxy_qianfan_proxy_api_key={Ihr-api-key}
# proxy_qianfan_proxy_api_secret={ihr-geheimer-schlüssel}

• Extraktion von Wissensgraphen -> Wissensgraphen

class TripletExtractor(LLMExtractor).
"""TripletExtractor class.""""

def __init__(self, llm_client: LLMClient, model_name: str).
"""Den TripletExtractor initialisieren."""""
super(). __init__(llm_client, model_name, TRIPLET_EXTRACT_PT)

TRIPLET_EXTRACT_PT = (
"Im Folgenden wird ein Text angegeben, aus dem "
"extrahiere so viele Wissenstripletts wie möglich "
" "in der Form von (Subjekt, Prädikat, Objekt). \n"
"Vermeiden Sie Stoppwörter. Das Subjekt, Prädikat und Objekt dürfen nicht fehlen. \n"
"---------------------\n"
"Beispiel:\n"
"Text: Alice ist Bobs Mutter.\n"
"Drillinge:\n(Alice, ist Mutter von, Bob)\n"
"Text: Alice hat 2 Äpfel.\n"
"Drillinge:\n(Alice, hat 2, Äpfel)\n"
"Text: Alice hat 1 Apfel von Bob bekommen.\n"
"Drillinge:(Bob, gibt 1 Apfel, Alice)\n"
"Text: Alice wurde von Bob geschubst.\n"
"Drillinge:(Bob, schubst, Alice)\n"
"Text: Bobs Mutter Alice hat 2 Äpfel.\n"
"Drillinge:\n(Alice, ist Mutter von, Bob)\n(Alice, hat 2, Äpfel)\n"
"Text: Ein großer Affe kletterte auf den hohen Obstbaum und pflückte 3 Pfirsiche.\n"
"Drillinge:\n(Affe, kletterte hoch, Obstbaum)\n(Affe, pflückte 3, Pfirsich)\n"
"Text: Alice hat 2 Äpfel, sie gibt 1 an Bob.\n"
"Drillinge:\n"
"(Alice, hat 2, Apfel)\n(Alice, gibt 1 Apfel, Bob)\n"
"Text: Philz ist ein Coffeeshop, der 1982 in Berkeley gegründet wurde.\n"
"Drillinge:\n"
"(Philz, ist, Coffeeshop)\n(Philz, gegründet in, Berkeley)\n"
"(Philz, gegründet in, 1982)\n"
"---------------------\n"
"Text: {Text}\n"
"Drillinge:\n"
)

• • Umgekehrte Index-Extraktion -> Segmentierung der Schlüsselwörter
    • Sie können das es-Standardlexikon verwenden oder das Lexikon mit Hilfe des es-Plugin-Modus anpassen.
• Speicherung von Wissen

Die gesamte Wissenspersistenz wird einheitlich erreichtIndexStoreBaseSchnittstelle, bietet derzeit drei Arten von Implementierungen: Vektordatenbanken, Graphdatenbanken, Volltextindizierung

• VectorStore, die Hauptlogik der Vektordatenbank befindet sich in load_document(), einschließlich der Erstellung des Indexschemas, des Batch-Schreibens von Vektordaten und so weiter.

# Hierarchie der Basisklassen
- VectorStoreBase
- ChromaSpeicher
- MilvusSpeicher
- OceanbaseSpeicher
- ElasticsearchSpeicher
- PGVektorSpeicher

# Definition der Basisklasse
class VectorStoreBase(IndexStoreBase, ABC).
"""
Vektorspeicher-Basisklasse.
"""

@abstractmethod
def load_document(self, chunks: List[Chunk]) -> List[str].
"""
Dokument in die Indexdatenbank laden.
"""
pass

@abstrakteMethode
async def aload_document(self, chunks: List[Chunk]) -> List[str].
"""
Dokument asynchron in die Indexdatenbank laden.
"""
pass

@abstrakteMethode
def similar_search_with_scores(
self.
text: str,
topk: int,
score_threshold: float,
filters: Optional[MetadataFilters] = None,
) -> Liste[Chunk].
"""
Führen Sie eine ähnliche Suche mit den Punktzahlen in der Indexdatenbank durch.
"""
übergeben.

def similar_search(
def similar_search(
text: str,
topk: int, filters: Optional[MetadataFilters] = None, def
filters: Optional[MetadataFilters] = None,
) -> List[Chunk].
"""
Führen Sie eine ähnliche Suche in der Indexdatenbank durch.
"""
return self.similar_search_with_scores(text, topk, 1.0, filters)

• GraphStore , ein konkreter Graphenspeicher, bietet eine Implementierung des ternären Schreibens, das im Allgemeinen durch den Aufruf der Abfragesprache einer konkreten Graphendatenbank erfolgt. Zum BeispielTuGraphStoreAuf der Grundlage der Tripel werden spezifische Cypher-Anweisungen generiert und ausgeführt.

• • Die Graphenspeicherschnittstelle GraphStoreBase bietet eine einheitliche Abstraktion für die Graphenspeicherung und verfügt derzeit über integrierteMemoryGraphStoreim Gesang antwortenTuGraphStoreImplementierung stellen wir Entwicklern auch eine Neo4j-Schnittstelle für den Zugriff zur Verfügung.

# GraphStoreBase -> TuGraphStore -> Neo4jStore
def insert_triplet(self, subj: str, rel: str, obj: str) -> None.
"""Triplett hinzufügen.""""
# Erstellen von Abfragen zum Zusammenführen von Knoten und Beziehungen
subj_query = f "MERGE (n1:{self._node_label} {{id:'{subj}'}})""
obj_query = f "MERGE (n2:{self._node_label} {{id:'{obj}'}})"
rel_query = (
f "MERGE (n1:{self._node_label} {{id:'{subj}'}})""
f"-[r:{self._edge_label} {{id:'{rel}'}}]->"
f"(n2:{self._node_label} {{id:'{obj}'}})"
)
# Ausführen von Abfragen
self.conn.run(abfrage=subj_abfrage)
self.conn.run(abfrage=obj_abfrage)
self.conn.run(abfrage=rel_abfrage)

• • FullTextStore: durch den Aufbau von es-Index, durch es eingebauten Worttrennungsalgorithmus für Worttrennung, und dann durch es zum Aufbau von Schlüsselwort->doc_id invertierten Index.

{
"Analyse": {
"analyser": {
"default": {
"type": "standard"
}
}
}, "similarity": { "default": { "type": "standard" }
"similarity": {
"custom_bm25": {
"type": "BM25",
"k1": self._k1,
"b": self._b
}
}
}

self._es_mappings = {
"properties": {
"content": {
"type": "text", "similarity": "custom_bm25
"similarity": "custom_bm25"
},
"metadata": {
"type": "keyword"
}
}
}

# FullTextStoreBase
# ElasticDocumentStore
# OpenSearchStore

2. das Abrufen von Wissen

Frage -> Rewrite -> Ähnlichkeitssuche -> Rangfolge -> Kontextkandidaten

Als nächstes ist die Wissensabfrage, die aktuelle Community Retrieval-Logik ist vor allem in diese Schritte unterteilt, wenn Sie die Abfrage Rewriting-Parameter eingestellt, wird derzeit geben Sie eine Runde der Frage Rewriting durch das große Modell, und dann wird es auf die entsprechende Retriever nach Ihrem Wissen Verarbeitung Weg geroutet werden, wenn Sie durch die Vektoren verarbeitet werden, wird es durch die EmbeddingRetriever abgerufen werden, wenn Sie bauen Weg durch den Wissensgraphen aufgebaut ist, wird es entsprechend dem Wissensgraphen abgerufen, und wenn Sie das Rerank-Modell einrichten, wird es den Kandidatenwerten nach dem Grobscreening ein Feinscreening geben, um die Kandidatenwerte relevanter für die Frage des Benutzers zu machen.

• EmbeddingRetriever

class EmbeddingRetriever(BaseRetriever).
"""EinbettenderRetriever."""""

def __init__(
self, __init__(
index_store: IndexStoreBase,
top_k: int = 4,
query_rewrite: Optional[QueryRewrite] = None,
rerank: Optional[Ranker] = None,
retrieve_strategy: Optional[RetrieverStrategy] = RetrieverStrategy.EMBEDDING,
).
EMBEDDING, ): pass

async def _aretrieve_with_score(
self.
self, query: str, score_threshold: float, score_with_score(
score_threshold: float, filters: Optional[MetadataFilters] = None, }
filters: Optional[MetadataFilters] = None, ) -> List[Chunk].
) -> List[Chunk].
"""
Abrufen von Wissensbrocken mit Bewertung.

Args.
Args: query (str): Abfragetext.
score_threshold (float): Schwellenwert für die Bewertung.
filters: Metadaten-Filter.

Rückgabe: List[Chunk]: Liste der Chunks mit Punktzahl.
List[Chunk]: Liste der Chunks mit Wertung.
"""
Abfragen = [Abfrage]

new_queries = await self._query_rewrite.rewrite(
origin_query=query,
context=Kontext,
nums=1
)
queries.extend(new_queries)

kandidaten_mit_punktzahl = [
self._similarity_search_with_score(
Abfrage,
score_threshold,
filter, root_tracer.get_current_span_id()
root_tracer.get_current_span_id()
)
for abfrage in abfragen
]

new_candidates_with_score = await self._rerank.arank(
new_candidates_with_score,
neue_kandidaten_mit_punktzahl, abfrage
)

return neue_Kandidaten_mit_Punktzahl

• • index_store: spezifische Vektordatenbank
  • top_k: die Anzahl der zurückgegebenen spezifischen Kandidaten-Chunks
  • query_rewrite: Funktion zum Umschreiben von Abfragen
  • rerank: Funktion zur Neuordnung
  • Abfrage:Originalabfrage
  • score_threshold: Wert, standardmäßig werden Kontexte mit einem Ähnlichkeitswert kleiner als der Schwellenwert herausgefiltert
  • Filter:Optional[MetadataFilters]Der Metadaten-Informationsfilter kann vor allem dazu verwendet werden, aus den Attribut-Informationen einige nicht übereinstimmende Kandidaten-Informationen auszusieben.

from enum import Enum
from typing import Union, Liste
from pydantic import BaseModel, Feld

class FilterCondition(str, Enum).
"""Vector Store Metadaten Filterbedingungen.""""
AND = "und"
OR = "oder"

class MetadatenFilter(BaseModel).
"""Metadaten-Filter.""""
Schlüssel: str = Feld(
... ,
description="Der Schlüssel der zu filternden Metadaten.""
)
operator: FilterOperator = Feld(
default=FilterOperator.EQ, description="Der Operator des Metadatenfilters.", description="Der Schlüssel der zu filternden Metadaten.")
EQ, description="Der Operator des Metadatenfilters."
)
value: Union[str, int, float, List[str], List[int], List[float]] = Feld(
... ,
description="Der Wert der zu filternden Metadaten."
)

• Grafik RAG

Erstens, Keyword-Extraktion wird durch das Modell durchgeführt, hier kann durch die traditionelle nlp Technik für Wort-Splitting, oder durch das große Modell für Wort-Splitting, und dann die Schlüsselwörter sind in Übereinstimmung mit den Synonymen zu tun, die Erweiterung, um die Keyword-Kandidaten-Liste zu finden, und es ist besser, die Explore-Methode aufrufen, um die lokalen Teilgraphen nach der Keyword-Kandidaten-Liste abrufen.

KEYWORD_EXTRACT_PT = (
"Im Folgenden wird eine Frage gestellt. Extrahieren Sie aus dem Text bis zu " "Schlüsselwörter.
Ausgehend von der Frage extrahiere bis zu " "Schlüsselwörter aus dem Text. Konzentriere dich darauf, die Schlüsselwörter zu extrahieren, " "die wir verwenden können.
Konzentrieren Sie sich darauf, die Schlüsselwörter zu extrahieren, " "mit denen wir die Antworten auf die Frage am besten nachschlagen können.\n"
" "Generieren Sie so viele Synonyme oder Alias der Schlüsselwörter wie möglich, " "unter Berücksichtigung möglicher Groß- und Kleinschreibung," " "um die besten Antworten auf die Frage zu finden.
" "unter Berücksichtigung möglicher Großschreibung, Pluralisierung, "
"gebräuchliche Ausdrücke, etc.\n"
" "Vermeiden Sie Stoppwörter.\n"
"Geben Sie die Schlüsselwörter und Synonyme im kommagetrennten Format an."
"Formatierter Text für Schlüsselwörter und Synonyme sollte durch ein Semikolon getrennt werden.\n" "\n"
"---------------------\n"
"Beispiel:\n"
"Text: Alice ist Bobs Mutter.\n"
"Schlüsselwörter:\nAlice,Mutter,Bob;Mutti\n"
"Text: Philz ist ein Coffeeshop, der 1982 in Berkeley gegründet wurde.\n"
"Stichworte:\nPhilz,Coffeeshop,Berkeley,1982;Kaffeebar,Kaffeehaus\n"
"---------------------\n"
"Text: {Text}\n"
"Schlüsselwörter:\n"
)

def explore(
self, subs.
subs: List[str], direct: Direction = Direction.
direct: Direction = Direction.
depth: Optional[int] = None, fan: Optional[int] = None,
fan: Optional[int] = None, fan: Optional[int] = None,
limit: Optional[int] = None,
) -> Graph.
"""Erkunden auf graph."""""

• DBSchemaRetrieverDies ist teilweise eine schemaverknüpfende Suche nach ChatData-Szenarien

  Hauptsächlich durch Schema-Verknüpfung durch zweistufige Ähnlichkeitssuche, zuerst die relevanteste Tabelle, dann die relevanteste Feldinformation.

  Vorteile: Diese zweistufige Suche soll auch das Feedback der Community zur Erfahrung mit großen, breiten Tischen berücksichtigen.

def _similarity_search(self, query, filters: Optional[MetadataFilters] = None) -> List[Chunk].
"""Ähnliche Suche."""

# Ähnlichkeitssuche mit Scores durchführen
table_chunks = self._table_vector_store_connector.similar_search_with_scores(
Abfrage, self._top_k, 0, Filter
)

# Herausfiltern von Chunks mit "getrennten" Metadaten
not_sep_chunks = [
chunk for chunk in table_chunks if not chunk.metadata.get("separated")
]
separated_chunks = [
chunk for chunk in table_chunks if chunk.metadata.get("separated")
]

# Wenn keine getrennten Stücke, gib die nicht getrennten Stücke zurück
if not separated_chunks: return not_sep_chunks
return not_sep_chunks

# Erstellen einer Aufgabenliste zum Abrufen von Feldern aus getrennten Chunks
tasks = [
lambda c=chunk: self._retrieve_field(c, query) for chunk in separated_chunks
]

# Gleichzeitige Ausführung von Aufgaben mit einer Gleichzeitigkeitsgrenze von 3
separated_result = run_tasks(tasks, concurrency_limit=3)

# Kombinieren und Rückgabe der Ergebnisse
return not_sep_chunks + separated_result

• • table_vector_store_connector: ist für das Abrufen der wichtigsten Tabelle zuständig.
  • field_vector_store_connector: ist für das Abrufen der wichtigsten Felder zuständig.

2. wissensverarbeitende und wissensabrufende Optimierungsideen

Derzeit gibt es bei den RAG-Smart-Quiz-Anwendungen mehrere Schwachstellen:

• Nachdem immer mehr Dokumente in der Wissensdatenbank vorhanden sind, ist die Suche verrauscht und die Auffindungsgenauigkeit ist nicht hoch.
• Unvollständige Rückrufe und Unvollständigkeit
• Rückrufe und die Absicht der Nutzer, eine Frage zu stellen, sind wenig relevant
• Nur statische Daten beantworten zu können und nicht in der Lage zu sein, dynamisch auf Wissen zuzugreifen, führt zu einer langweiligen und dummen Antwortanwendung.

1. Optimierung der Wissensverarbeitung

Die Verarbeitung von unstrukturierten/halbstrukturierten/strukturierten Daten ist bereit, die Obergrenze der RAG-Anwendung zu bestimmen, so dass zunächst eine Menge feinkörniger ETL-Arbeit in der Wissensverarbeitung, der Indizierungsphase und der Hauptoptimierung der Richtung der Idee erforderlich ist:

• Unstrukturiert -> Strukturiert: Organisation von Wissensinformationen auf strukturierte Weise.
• Extrahieren Sie umfangreichere und vielfältigere semantische Informationen.

 1.1 Wissen laden

Zweck: Genaues Parsing von Dokumenten ist erforderlich, um verschiedene Datentypen auf vielfältigere Weise zu identifizieren.

Optimierungsempfehlungen:

• Es wird empfohlen, docx, txt oder anderen Text vor der Verarbeitung für pdf oder markdown-Format, so dass Sie einige Erkennungs-Tools verwenden können, um besser den Inhalt des Textes zu extrahieren.
• Extrahiert Tabelleninformationen aus Text.
• Bewahren Sie Markdown- und PDF-Titelhierarchieinformationen für den nächsten hierarchischen Beziehungsbaum und andere Indizierungsmethoden, die Sie vorbereiten müssen.
• Behalten Sie Bildverknüpfungen, Formeln und andere Informationen bei, die ebenfalls einheitlich im Markdown-Format verarbeitet werden.

 1.2 Chunk möglichst unversehrt in Scheiben schneiden

Zweck: Wahrung der kontextuellen Integrität und Relevanz, die in direktem Zusammenhang mit der Antwortgenauigkeit stehen.

Durch Chunking wird sichergestellt, dass die Texteingabe in die LLMs deren Token-Grenzen nicht überschreitet, wobei die kontextuellen Grenzen des größeren Modells eingehalten werden.

Optimierungsempfehlungen:

• Bilder + Tabellen werden als separate Chunks extrahiert, wobei Tabellen- und Bildunterschriften in den Metadaten verbleiben
• Der Inhalt des Dokuments wird so weit wie möglich gemäß der Kopfzeilenhierarchie oder dem Markdown-Header aufgeteilt, wobei die Integrität des Chunks so weit wie möglich erhalten bleibt.
• Wenn ein benutzerdefiniertes Trennzeichen vorhanden ist, können Sie die Daten anhand des benutzerdefinierten Trennzeichens zerlegen.

 1.3 Diversifizierte Informationsextraktion

Zusätzlich zur Einbettung der Vektorextraktion von Dokumenten können andere diversifizierte Informationsextraktionen die Daten von Dokumenten verbessern und den RAG-Recall-Effekt erheblich steigern.

• Wissenslandkarte
  • • Vorteile: 1. die mangelnde Vollständigkeit der NativeRAG, gibt es immer noch das Problem der Illusion, und die Genauigkeit des Wissens, einschließlich der Vollständigkeit des Wissens Grenzen, die Klarheit des Wissens Struktur und Semantik, ist eine semantische Ergänzung zu der Fähigkeit der Ähnlichkeit Retrieval.
    • Szenarien: Für strenge berufliche Bereiche (Gesundheitswesen, O&M, usw.), in denen die Aufbereitung von Wissen eingeschränkt werden muss und in denen hierarchische Beziehungen zwischen Wissen klar festgelegt werden können.
    • Wie man das erreicht:

      1. auf das große Modell angewiesen, um ternäre Beziehungen (Entität, Beziehung, Entität) zu extrahieren.

      2. sich auf die Vorbereitung, Bereinigung und Extraktion von strukturiertem Wissen von hoher Qualität durch manuelle oder benutzerdefinierte SOPs zu verlassen, um den Wissensgraphen zu erstellen.

• Doc Tree
  • • Anwendbare Szenarien: löst das Problem der unzureichenden kontextuellen Integrität, bietet aber auch Übereinstimmungen allein auf der Grundlage von Semantik und Schlüsselwörtern und kann Rauschen reduzieren
    • Vorgehensweise: Aufbau eines Baumknotens aus Chunks auf der Titelebene, um eine multinomiale Baumstruktur zu bilden, bei der jeder Knoten der Ebene nur den Titel des Dokuments speichern muss und die Blattknoten den spezifischen Textinhalt speichern. Wenn eine Benutzerfrage auf einen relevanten nicht-blättrigen Titelknoten trifft, können auf diese Weise mit Hilfe des Baum-Traversal-Algorithmus die relevanten Daten der untergeordneten Knoten abgerufen werden. Auf diese Weise gibt es kein Problem mit der Integrität von Chunks.

Diesen Teil des Features werden wir Anfang nächsten Jahres auch in die Gemeinschaft einbringen.

• Die Extraktion von QA-Paaren erfordert eine Front-End-Extraktion von QA-Paarinformationen durch vordefinierte oder Modellextraktionsmethoden

• • Anwendbare Szenarien:

• • • Die Fähigkeit, die Frage in den Abruf und direkten Rückruf zu treffen, direkt abrufen die Antwort der Benutzer will, gilt für einige FAQ-Szenarien, Recall-Integrität ist nicht genug Szenarien.

• • Wie man das erreicht:

• • • Vordefiniert: Fügen Sie im Voraus einige Fragen für jeden Chunk hinzu.
    • Modellextraktion: In einem gegebenen Kontext soll das Modell die Extraktion von QA-Paaren durchführen.

• Extraktion von Metadaten

• • So erreichen Sie es: Extrahieren Sie je nach den Merkmalen ihrer eigenen Geschäftsdaten die Merkmale der aufzubewahrenden Daten, wie Tags, Kategorien, Zeit, Version und andere Metadatenattribute.
  • Anwendbare Szenarien: Der Abruf kann auf der Grundlage von Metadatenattributen vorgefiltert werden, um den größten Teil des Rauschens herauszufiltern.

• Zusammenfassen und extrahieren

• • Anwendbare Szenarien: AuflösungWorum geht es in diesem Artikel?(math.) GattungZusammengefasst.und andere globale Problemszenarien.
  • Umsetzung: segmentierte Extraktion über Mapreduce usw., Extraktion von zusammenfassenden Informationen für jeden Chunk über ein Modell.

 1.4 Arbeitsablauf der Wissensverarbeitung

zum gegenwärtigen Zeitpunkt DB-GPT Die Wissensdatenbank bietet Wissensverarbeitungsfunktionen wie Upload von Dokumenten -> Parsing -> Slicing -> Embedding -> Extraktion von Wissensgraphen-Triaden -> Speicherung in einer Vektordatenbank -> Speicherung in einer Graphen-Datenbank usw., ist aber nicht in der Lage, komplexe und personalisierte Informationen aus Dokumenten zu extrahieren. Daher hoffen wir, durch den Aufbau einer Workflow-Vorlage für die Wissensverarbeitung den komplexen, visuellen, benutzerdefinierten Prozess der Extraktion, Umwandlung und Verarbeitung von Wissen zu vervollständigen. Daher hoffen wir, eine Workflow-Vorlage für die Wissensverarbeitung erstellen zu können, um den komplexen, visuellen, benutzerdefinierten Prozess der Wissensextraktion, -umwandlung und -verarbeitung zu vervollständigen.

Workflow der Wissensverarbeitung:

https://www.yuque.com/eosphoros/dbgpt-docs/vg2gsfyf3x9fuglf

2. RAG Prozessoptimierung RAG Prozessoptimierung sind wir in das statische Dokument RAG und dynamische Datenerfassung RAG unterteilt, die meisten der aktuellen RAG beteiligt deckt nur das unstrukturierte Dokument statische Vermögenswerte, aber das eigentliche Geschäft von vielen Szenarien der Q & A ist durch das Werkzeug, um dynamische Daten + statische Wissensdaten zusammen zu erhalten, um das Szenario zu beantworten, nicht nur brauchen, um das statische Wissen abzurufen, sondern müssen auch RAG sein nicht nur das statische Wissen abrufen, sondern auch RAG benötigen, um die Informationen von Werkzeugen innerhalb der Werkzeug-Asset-Bibliothek abzurufen und den Erwerb von dynamischen Daten durchzuführen.

 2.1 Statisches Wissen RAG-Optimierung

(1) Behandlung des ursprünglichen Problems

Zweck: Klärung der Benutzersemantik und Optimierung der ursprünglichen Frage des Benutzers von einer unscharfen, schlecht definierten Abfrage zu einer abrufbaren Abfrage mit größerer Aussagekraft.

• Rohe Problemklassifizierung, mit der Probleme in folgende Kategorien eingeteilt werden können

• • LLM-Klassifizierung (LLMExtractor)
  • Aufbau von Einbettung + logistischer Regression zur Implementierung eines Zweiturm-Modells, text2nlu DB-GPT-Hub/src/dbgpt-hub-nlu/README.zh.md bei main - eosphoros-ai/DB-GPT-Hub

• • • Tipp: Benötigen Sie hohe Qualität Embedding Modell, empfehlen bge-v1.5-groß

• Fragen Sie den Benutzer zurück, und wenn die Semantik nicht klar ist, werfen Sie die Frage an den Benutzer zurück, um sie zu klären, und zwar in mehreren Runden der Interaktion.

• • Schlägt dem Benutzer auf der Grundlage der semantischen Relevanz und unter Verwendung eines durchsuchbaren Thesaurus eine Auswahlliste von Fragen vor.

• Slot-Extraktion, die darauf abzielt, wichtige Slot-Informationen in der Frage des Benutzers zu erhalten, wie z. B. Absicht, geschäftliche Attribute usw.

• • LLM-Extraktion (LLMExtractor)

• Die Frage umschreiben

• • Neufassung des Hot Search Thesaurus
  • vielschichtige Interaktion

(2) Filterung von Metadaten

Wenn wir den Index in viele Chunks aufteilen und diese im selben Wissensraum gespeichert werden, wird die Abrufeffizienz zu einem Problem. Wenn Benutzer beispielsweise nach Informationen über "Zhejiang I Wu Technology Company" suchen, wollen sie keine Informationen über andere Unternehmen abrufen. Wenn Sie also zuerst nach dem Metadatenattribut "Firmenname" filtern können, wird dies die Effizienz und Relevanz erheblich verbessern.

async def aretrieve(
self, Abfrage: str, async
abfrage: str, async
filters: Optional[MetadataFilters] = None
) -> List[Chunk].
"""
Abrufen von Wissensbrocken.

Args.
Args: query (str): asynchroner Abfragetext.
filters (Optional[MetadataFilters]): Metadatenfilter.

Rückgabe: List[Chunk]: Liste von Chunks.
List[Chunk]: Liste von Chunks
"""
return await self._aretrieve(Abfrage, Filter)

(3) Multistrategie-Hybrid-Rückruf

• Festlegung von Prioritäten für verschiedene Abrufer je nach Abrufpriorität und Rückgabe von Inhalten, sobald diese abgerufen wurden
  • • Definieren Sie verschiedene Abrufe wie qa_retriever, doc_tree_retriever, die in die Warteschlange geschrieben werden sollen, und erreichen Sie einen vorrangigen Abruf durch die First-in-first-out-Eigenschaft der Warteschlange.

class RetrieverChain(BaseRetriever).
"""Retriever-Kette Klasse.""""

def __init__(
self, Retriever: Optional[Liste[BaseRetriever]] = None, None
retrievers: Optional[List[BaseRetriever]] = None,
Executor: Optional[Executor] = None,
).
"""Retriever-Kette erstellen instance.""""
self._Retriever = Retriever oder []
self._executor = executor oder ThreadPoolExecutor()

async def retrieve(self, query: str, score_threshold: float, filters: Optional[dict] = None).
"""Abruf mit der angegebenen Abfrage, dem Schwellenwert und den Filtern durchführen.""""
for retriever in self._retrievers.
candidates_with_scores = await retriever.aretrieve_with_scores(
query=Abfrage, score_threshold=Score_threshold, filters=Filter
)

if candidate_with_scores.
return candidate_with_scores

• Indizierung von Mehrfachwissen/paralleler räumlicher Abruf
  • • Ermittlung von Kandidatenlisten durch parallelen Abruf durch verschiedene Indizierungsformen des Wissens, um die Vollständigkeit des Abrufs zu gewährleisten

(4) Nachfilterung

Wie filtern Sie nach dem Grobscreening der Kandidatenliste das Rauschen durch das Feinscreening?

• Aussortieren irrelevanter Kandidaten-Slice
  • • Ablehnung der Rechtzeitigkeit
    • Business-Attribute genügen nicht den Anforderungen des Culling

• topk-Deduplizierung
• Neuordnung Es reicht nicht aus, sich auf den Abruf des Grobscreenings zu verlassen. Zu diesem Zeitpunkt benötigen wir einige Strategien, um die abgerufenen Ergebnisse neu zu ordnen, z. B. um Faktoren wie Kombinationsrelevanz, Übereinstimmung usw. neu zu justieren, um eine Ordnung zu erhalten, die besser mit unseren Geschäftsszenarien übereinstimmt. Denn nach diesem Schritt werden wir die Ergebnisse zur endgültigen Verarbeitung an LLM senden, so dass die Ergebnisse dieses Teils sehr wichtig sind.

   

  • Feinscreening unter Verwendung relevanter Neuordnungsmodelle, entweder Open-Source-Modelle oder Modelle mit unternehmenssemantischer Feinabstimmung.

## Rerank-Modell
# RERANK_MODEL = bce-reranker-base

##### Wenn Sie RERANK_MODEL_PATH nicht festlegen, liest DB-GPT den Modellpfad aus EMBEDDING_MODEL_CONFIG auf der Grundlage des RERANK_MODEL.
# RERANK_MODEL_PATH = /Users/chenketing/Desktop/project/DB-GPT-NEW/DB-GPT/models/bce-reranker-base_v1

##### Die Anzahl der zurückzugebenden Rerank-Ergebnisse
# RERANK_TOP_K = 5

• • Business RRF-gewichtetes Composite Score Culling auf der Basis verschiedener indizierter Rückrufe

Punktzahl = 0,0

for q in Abfragen: if d in ergebnis(q)
if d in result(q): score += 1.0 / (k + rank(result(q), d))
Punktzahl += 1,0 / (k + Rang(Ergebnis(q), d))

Punktzahl zurückgeben

# wobei.
# k eine Rangkonstante ist
# q eine Abfrage in der Menge der Abfragen ist
# d ist ein Dokument in der Ergebnismenge von q
# result(q) ist die Ergebnismenge von q
# Rang(result(q), d) ist der Rang von d innerhalb von result(q), beginnend bei 1

(5) Display-Optimierung + Touting / Themen-Leads

• Ausgabe des Modells mit Markdown-Formatierung

Befolgen Sie auf der Grundlage der nachstehenden Informationen die normativen Vorgaben und beantworten Sie die Fragen des Benutzers professionell und kurz.

Normative Beschränkungen:
Wenn die bekannten Informationen Bilder, Links, Tabellen, Code-Blöcke und andere spezielle Markdown-Tag-Formate enthalten, stellen Sie sicher, dass Sie den Originaltext dieser Bilder, Links, Tabellen und Code-Tags in Ihre Antwort einbeziehen und sie nicht verwerfen oder verändern, zum Beispiel:
- Bildformat: `! [bild.png](xxx)`
- Link-Format: `[xxx](xxx)`
- Tabellenformat: `|xxx|xxx|xxx|`
- Code-Format: ``xxx``.
2. wenn die Antwort nicht aus dem bereitgestellten Inhalt gewonnen werden kann, sagen Sie: ``Der in der Wissensdatenbank bereitgestellte Inhalt reicht nicht aus, um diese Frage zu beantworten''; das Erfinden von Dingen ist verboten.
3. die Antworten sollten vorzugsweise gemäß Punkt 1.2.3. zusammengefasst und im Markdown-Format angezeigt werden.

 2.2 Dynamische Wissens-RAG-Optimierung

Dokumentation Wissen ist relativ statisch, kann nicht beantworten, personalisierte und dynamische Informationen, müssen sich auf einige Drittanbieter-Plattform-Tools zu beantworten, auf der Grundlage dieser Situation, wir brauchen einige dynamische RAG-Ansatz, durch das Tool Asset-Definition -> Tool-Auswahl -> Tool-Validierung -> Tool-Ausführung, um dynamische Daten zu erhalten.

(1) Werkzeug-Bestandsbibliothek

Aufbau einer Tool-Asset-Bibliothek für den Unternehmensbereich zur Integration von Tool-APIs und Tool-Skripten, die auf verschiedenen Plattformen verstreut sind, und somit Bereitstellung von End-to-End-Nutzungsfunktionen für Intelligenz. Zusätzlich zur statischen Wissensbasis können wir beispielsweise Werkzeuge durch den Import von Werkzeugbibliotheken verarbeiten.

(2) Werkzeugrückruf

Der Werkzeugabruf folgt der Idee des RAG-Abrufs für statisches Wissen, und dann wird der gesamte Lebenszyklus der Werkzeugausführung verwendet, um die Ergebnisse der Werkzeugausführung zu erhalten.

• Slot-Extraktion: Holen Sie sich LLM durch traditionelle nlp, um das Problem des Benutzers zu analysieren, einschließlich gemeinsamer Geschäftstypen, Umgebungsmarker, Domänenmodellparameter usw.
• Werkzeugauswahl: Abruf nach dem Vorbild der statischen RAG mit zwei Hauptebenen, Abruf des Werkzeugnamens und Abruf der Werkzeugparameter.
  • • Beim Abruf von Werkzeugparametern wird, ähnlich wie bei TableRAG, zuerst der Tabellenname und dann der Feldname abgerufen.

• Parameterfüllung: Die aus den Schlitzen extrahierten Parameter müssen mit den Werkzeugparameterdefinitionen der Rückrufe übereinstimmen.
  • • Sie können den Code ausfüllen, oder Sie können ihn vom Modell ausfüllen lassen.
    • Optimierungsideen: Da die Parameternamen der gleichen Parameter der verschiedenen Plattform-Tools nicht einheitlich sind und es nicht bequem ist, sich an die Verwaltung zu wenden, wird vorgeschlagen, dass zunächst eine Runde der Domänenmodelldatenerweiterung durchgeführt werden kann und nach Erhalt des gesamten Domänenmodells die erforderlichen Parameter vorhanden sein werden.

• Parameterkalibrierung
  • • Integritätsprüfung: führt eine Integritätsprüfung für die Anzahl der Parameter durch
    • Parameter-Regelprüfung: Führt eine Regelprüfung für Parameternamen, Parameterwerte, Aufzählungen usw. durch.

• Parameterkorrektur/-anpassung, dieser Teil dient hauptsächlich dazu, die Anzahl der Interaktionen mit dem Benutzer zu reduzieren, automatischer Abschluss der Benutzerparameter-Fehlerkorrektur, einschließlich Fallregeln, Aufzählungsregeln, usw. z.B.

 2.3 RAG-Überprüfung

Bei der Bewertung des Smart Q&A-Prozesses müssen sowohl die Genauigkeit der Abrufrelevanz als auch die Relevanz des Modells Q&A separat bewertet und dann zusammen betrachtet werden, um festzustellen, wo der RAG-Prozess noch verbessert werden muss.

Bewertung der Indikatoren:

BewertungMetrik
LLMEvaluationMetric
│ ├── AnswerRelevancyMetric
├── RetrieverEvaluationMetric
│ ├── RetrieverSimilarityMetric
│ ├── RetrieverMRRMetric
│ └── RetrieverHitRateMetric

• RAGRetrieverEvaluationMetric:
  • • RetrieverHitRateMetric:: Die Trefferquote misst die RAGRetrieverDer Anteil der Rückrufe, die in den Top-k-Dokumenten der Abrufergebnisse erscheinen.
    • RetrieverMRRMetrik:Mittlerer reziproker RangDie Genauigkeit jeder Anfrage wird durch die Analyse der Rangfolge der relevantesten Dokumente in den Suchergebnissen berechnet. Genauer gesagt handelt es sich um den Durchschnitt des inversen Rangs der relevanten Dokumente für alle Suchanfragen. Wenn zum Beispiel das relevanteste Dokument an erster Stelle steht, ist sein inverser Rang 1; wenn es an zweiter Stelle steht, ist er 1/2 usw.
    • RetrieverSimilarityMetricÄhnlichkeitsmetriken werden berechnet, um die Ähnlichkeit zwischen dem abgerufenen Inhalt und dem vorhergesagten Inhalt zu ermitteln.

       

Erzeugung von ModellenAntwort-Indikator.

• AnswerRelevancyMetric:: Relevanzmetrik für intelligente Antworten, die angibt, wie gut die Antwort des intelligenten Körpers mit der Frage des Nutzers übereinstimmt. Eine Antwort mit hoher Relevanz setzt nicht nur voraus, dass das Modell die Frage des Nutzers versteht, sondern auch, dass es eine Antwort generiert, die in engem Zusammenhang mit der Frage steht. Dies wirkt sich direkt auf die Benutzerzufriedenheit und die Nützlichkeit des Modells aus.

  3.RAG Landing Case Sharing

1. die RAG im Bereich der Dateninfrastruktur

 1.1 O&M Intelligence Body Hintergrund

Im Bereich der Dateninfrastruktur gibt es viele Ops SREs, die täglich eine große Anzahl von Warnmeldungen erhalten, so dass viel Zeit damit verbracht wird, auf Notfälle zu reagieren, was wiederum zur Fehlerbehebung und zur Überprüfung der Fehlerbehebung führt, was wiederum zu Erfahrung führt. Ein weiterer Teil der Zeit wird mit der Beantwortung von Benutzeranfragen verbracht, bei denen sie Fragen mit ihrem Wissen und ihrer Erfahrung bei der Verwendung der Tools beantworten müssen.

Daher hoffen wir, diese Probleme der Alarmdiagnose und der Beantwortung von Fragen zu lösen, indem wir eine allgemeine Intelligenz für die Dateninfrastruktur schaffen.

 1.2 Strenge und professionelle RAG

Die traditionelle RAG + Agent Technologie kann allgemeine, weniger deterministische, einstufige Aufgabenszenarien lösen. Bei professionellen Szenarien im Bereich der Dateninfrastruktur muss jedoch der gesamte Retrievalprozess deterministisch, professionell und realistisch sein und erfordert schrittweises Denken.

Auf der rechten Seite finden Sie eine allgemeine Zusammenfassung über NativeRAG, die für einen C-Suite-Benutzer, der nicht so viel Fachwissen hat, eine nützliche Information sein kann, und für einen Fachmann wird dieser Teil der Antwort nicht viel Sinn machen.

Wir vergleichen daher den Unterschied zwischen den allgemeinen Intelligenzen und den Intelligenzen der Dateninfrastruktur über die RAG:

• Allzweck-Intelligenzen: Herkömmliche RAGs erfordern nicht so viel intellektuelle Strenge und Fachwissen und eignen sich für einige Geschäftsszenarien, wie z. B. Kundenservice, Tourismus und Plattform-Q&A-Bots.
• Data Infrastructure Intelligence Body: Der RAG-Prozess ist streng und professionell und erfordert exklusive RAG-Workflows mit Kontexten, die (Alarmierung -> Lokalisierung -> Stoppen der Blutung -> Wiederherstellung) und eine strukturierte Extraktion von Fragen und Antworten sowie von Notfallerfahrungen, die von Experten ausgearbeitet wurden, um hierarchische Beziehungen herzustellen. Deshalb wählen wir Knowledge Graph als Datenträger.

 1.3 Wissensverarbeitung

Aufgrund des Determinismus und der Spezifität der Dateninfrastruktur haben wir uns entschieden, sie als Wissensträger für die Diagnose von Notfallreaktionserfahrungen durch die Kombination von Wissensgraphen zu verwenden. In Kombination mit dem Notfallüberprüfungsprozess haben wir einen DB-Notfall-Wissensgraphen erstellt. Wir haben DB-Jitter als Beispiel genommen, mehrere Ereignisse, die DB-Jitter betreffen, einschließlich langsamer SQL-Probleme und Kapazitätsprobleme, und wir haben Beziehungen zwischen den einzelnen Notfallereignissen hergestellt.

Schließlich haben wir ein standardisiertes Wissensverarbeitungssystem von Wissen aus mehreren Quellen -> strukturierte Wissensextraktion -> Extraktion von Notfallbeziehungen -> Überprüfung durch Experten -> Wissensspeicherung Schritt für Schritt durch Standardisierung der Regeln für Notfallereignisse aufgebaut.

 1.4 Wissensabfrage

In der Phase der intelligenten Suche verwenden wir GraphRAG als Träger der statischen Wissenssuche. Nachdem wir die DB-Jitter-Anomalie identifiziert haben, finden wir die Knoten, die mit dem DB-Jitter-Anomalie-Knoten verbunden sind, als Grundlage unserer Analyse, da jeder Knoten auch einige Metadaten-Informationen für jedes Ereignis in der Wissensextraktionsphase enthält, einschließlich des Ereignisnamens, der Ereignisbeschreibung, der zugehörigen Tools, der Tool-Parameter und so weiter.

Daher können wir die Rückgabeergebnisse über die Verknüpfung des Ausführungslebenszyklus des Ausführungswerkzeugs erhalten, um die dynamischen Daten zu erhalten, die als Grundlage für die Notfalldiagnose zur Fehlerbehebung dienen. Durch diesen dynamischen und statischen hybriden Rückrufansatz werden die Sicherheit, Professionalität und Strenge der Ausführung der Dateninfrastruktur-Intelligenzen im Vergleich zum reinen und einfachen RAG-Rückruf garantiert.

 1,5 AWEL + Mittel

Schließlich wurde durch die AWEL+AGENT-Technologie der Gemeinschaft das Paradigma der AGENT-Orchestrierung genutzt, um einen Experten zu schaffen, der von der Absicht -> Notfalldiagnose-Experte -> Experte für die Ursachenanalyse ist.

Jeder Agent hat eine andere Funktion. Der Intent-Experte ist dafür verantwortlich, die Absicht des Benutzers zu erkennen und zu analysieren und Warnmeldungen zu identifizieren. Der Diagnose-Experte muss den zu analysierenden Grundursachenknoten mit Hilfe von GraphRAG ausfindig machen und spezifische Grundursacheninformationen erhalten. Der Analyseexperte muss die Daten jedes Ursachenknotens und den Bericht über die Überprüfung der historischen Analyse kombinieren, um einen diagnostischen Analysebericht zu erstellen.

2. die RAG im Bereich der Analyse der Finanzberichterstattung

Neueste Praxis! Wie erstellt man einen Assistenten für die Analyse von Finanzberichten auf der Grundlage von DB-GPT?

Sie können Ihr eigenes Repository von Domain-Assets, einschließlich Wissens-Assets, Tool-Assets und Wissensgraphen-Assets, rund um Ihre Domain aufbauen.

• Domänen-Assets: Zu den Domänen-Assets gehören Wissensdatenbanken, APIs und Tool-Skripte.
• Asset-Verarbeitung, die gesamte Asset-Datenverknüpfung umfasst die Domain-Asset-Verarbeitung, die Domain-Asset-Abfrage und die Domain-Asset-Auswertung.
  • • Unstrukturiert -> Strukturiert: kategorisiert in einer strukturierten Weise, korrekt organisierte Wissensinformationen.
    • Extrahieren umfassenderer semantischer Informationen.

• Asset Retrieval:
  • • Hoffentlich handelt es sich um eine hierarchische, nach Prioritäten geordnete Suche und nicht um eine Einzelsuche.
    • Die Nachfilterung ist wichtig, vorzugsweise durch die geschäftliche Semantik einiger Regeln.