Knowledge Graph mit Oracle Autonomous Database und Property Graph Query Language erstellen

Einführung

In diesem Tutorial werden die Konzepte der Diagrammtheorie, Wissensdiagramme und deren Implementierung mit Oracle Autonomous Database with Property Graph Query Language (PGQL) erläutert. Außerdem wird die Python-Implementierung erläutert, mit der Beziehungen aus Dokumenten mit LLMs extrahiert und als Diagrammstrukturen in Oracle gespeichert werden.

Was ist Graph?

Graph ist ein Bereich der Mathematik und Informatik, der sich auf die Modellierung von Beziehungen zwischen Objekten konzentriert. Ein Diagramm besteht aus:

Vertikale (Knoten): Stellt Entitys dar.
Kanten (Links): Stellt Beziehungen zwischen Entitys dar.

Diagramme werden häufig zur Darstellung von Datenstrukturen in sozialen Netzwerken, semantischen Netzwerken, Wissensdiagrammen und mehr verwendet.

Was ist ein Knowledge Graph?

Ein Wissensdiagramm ist eine grafikbasierte Darstellung des realen Wissens, wobei:

Knoten stellen Entitys wie Personen, Orte, Produkte usw. dar.
Kanten stellen semantische Beziehungen dar. Zum Beispiel, arbeitet bei, Teil von und mehr.

Wissensdiagramme verbessern semantische Such-, Empfehlungs- und Fragebeantworteranwendungen.

Warum Oracle Autonomous Database mit PGQL verwenden?

Oracle bietet eine vollständig verwaltete Umgebung zum Speichern und Abfragen von Eigenschaftsdiagrammen:

PGQL ist SQL-ähnlich und wurde für die Abfrage komplexer Diagrammmuster entwickelt.
Mit Oracle Autonomous Database können Diagrammabfragen nativ mit Eigenschaftsdiagrammfunktionen ausgeführt werden, einschließlich Erstellung, Abfrage und Visualisierung.
Die Integration mit LLMs ermöglicht die automatische Extraktion von Diagrammstrukturen aus unstrukturierten Daten (wie PDFs).

Vergleich mit anderen Diagrammabfragesprachen

Vorteile der Oracle Autonomous Database mit PGQL im Vergleich zu herkömmlichen Diagrammdatenbanken

Ziele

Erstellen Sie ein Wissensdiagramm mit Oracle Autonomous Database und PGQL.

Voraussetzungen

Installieren Sie Python version 3.10 oder höher und die Oracle Cloud Infrastructure-Befehlszeilenschnittstelle (OCI-CLI).

Aufgabe 1: Python-Packages installieren

Der Python-Code erfordert bestimmte Librarys zur Verwendung der generativen KI von Oracle Cloud Infrastructure (OCI). Führen Sie den folgenden Befehl durch, um die erforderlichen Python-Packages zu installieren. Sie können die Datei hier herunterladen: requirements.txt.

pip install -r requirements.txt

Aufgabe 2: Oracle Database 23ai erstellen (Immer kostenlos)

In dieser Aufgabe lernen wir, wie Sie eine Oracle Database 23ai im Modus Immer kostenlos bereitstellen. Diese Version bietet eine vollständig verwaltete Umgebung, ideal für Entwicklung, Tests und Lernen, ohne zusätzliche Kosten.

Melden Sie sich bei der OCI-Konsole an, navigieren Sie zu Oracle Database, Autonomous Database, und klicken Sie auf Autonomous Database-Instanz erstellen.
Geben Sie folgende Informationen ein.
- Datenbankname: Geben Sie einen identifizierenden Namen für die Instanz ein.
- Workload-Typ: Wählen Sie je nach Bedarf Data Warehouse oder Transaktionsverarbeitung aus.
- Compartment: Wählen Sie ein entsprechendes Compartment aus, um Ihre Ressourcen zu organisieren.
Wählen Sie Immer kostenlos aus, um sicherzustellen, dass die Instanz kostenlos bereitgestellt wird.
Erstellen Sie ein sicheres Kennwort für den Benutzer ADMIN, das für den Zugriff auf die Datenbank verwendet wird.
Prüfen Sie die Einstellungen, und klicken Sie auf Autonomous Database erstellen. Warten Sie einige Minuten, bis die Instanz bereitgestellt und zur Verwendung verfügbar ist.

Wenn Sie mit dem Prozess der Verbindung zu Oracle Autonomous Database nicht vertraut sind, folgen Sie diesen Links, um Ihren Code zu verstehen und ordnungsgemäß zu konfigurieren.

Hinweis: Sie müssen mit der Wallet-Methode eine Verbindung zur Datenbank in Ihrem Python-Code herstellen.

Aufgabe 3: Code herunterladen und verstehen

Ein sehr häufiger Anwendungsfall für Graph ist es, es als eine der Komponenten zu verwenden, die mit LLMs und einer Wissensdatenbank wie PDF-Dateien zusammenarbeiten.

Dieses Tutorial wird verwendet: PDF-Dokumente in natürlicher Sprache mit OCI Generative AI analysieren als Grundlage, die alle genannten Komponenten verwendet. Für den Zweck dieses Dokuments konzentrieren wir uns jedoch auf die Verwendung von Oracle Database 23ai zusammen mit Graph. Grundsätzlich wird der Python-Code (main.py) aus dem Basismaterial nur in den Teilen geändert, die Oracle Database 23ai verwenden.

Für diesen Service werden folgende Prozesse ausgeführt:

Erstellen Sie das Diagrammschema.
Extrahieren Sie Entitys und Beziehungen mit LLM.
Daten in Oracle einfügen.
Erstellen Sie das Eigenschaftsdiagramm.

Laden Sie den mit Oracle Database 23ai kompatiblen aktualisierten Python-Graphcode hier herunter: main.py.

create_knowledge_graph:

def create_knowledge_graph(chunks):
    cursor = oracle_conn.cursor()

    # Creates graph if it does not exist
    try:
        cursor.execute(f"""
        BEGIN
            EXECUTE IMMEDIATE '
                CREATE PROPERTY GRAPH {GRAPH_NAME}
                VERTEX TABLES (ENTITIES
                    KEY (ID)
                    LABEL ENTITIES
                    PROPERTIES (NAME))
                EDGE TABLES (RELATIONS
                    KEY (ID)
                    SOURCE KEY (SOURCE_ID) REFERENCES ENTITIES(ID)
                    DESTINATION KEY (TARGET_ID) REFERENCES ENTITIES(ID)
                    LABEL RELATIONS
                    PROPERTIES (RELATION_TYPE, SOURCE_TEXT))
            ';
        EXCEPTION
            WHEN OTHERS THEN
                IF SQLCODE != -55358 THEN -- ORA-55358: Graph already exists
                    RAISE;
                END IF;
        END;
        """)
        print(f"🧠 Graph '{GRAPH_NAME}' created or already exists.")
    except Exception as e:
        print(f"[GRAPH ERROR] Failed to create graph: {e}")

    # Inserting vertices and edges into the tables
    for doc in chunks:
        text = doc.page_content
        source = doc.metadata.get("source", "unknown")

        if not text.strip():
            continue

        prompt = f"""
        You are an expert in knowledge extraction.

        Given the following technical text:

        {text}

        Extract key entities and relationships in the format:
        - Entity1 -[RELATION]-> Entity2

        Use UPPERCASE for RELATION types.
        Return 'NONE' if nothing found.
        """
        try:
            response = llm_for_rag.invoke(prompt)
            result = response.content.strip()
        except Exception as e:
            print(f"[ERROR] Gen AI call error: {e}")
            continue

        if result.upper() == "NONE":
            continue

        triples = result.splitlines()
        for triple in triples:
            parts = triple.split("-[")
            if len(parts) != 2:
                continue

            right_part = parts[1].split("]->")
            if len(right_part) != 2:
                continue

            raw_relation, entity2 = right_part
            relation = re.sub(r'\W+', '_', raw_relation.strip().upper())
            entity1 = parts[0].strip()
            entity2 = entity2.strip()

            try:
                # Insertion of entities (with existence check)
                cursor.execute("MERGE INTO ENTITIES e USING (SELECT :name AS NAME FROM dual) src ON (e.name = src.name) WHEN NOT MATCHED THEN INSERT (NAME) VALUES (:name)", [entity1, entity1])
                cursor.execute("MERGE INTO ENTITIES e USING (SELECT :name AS NAME FROM dual) src ON (e.name = src.name) WHEN NOT MATCHED THEN INSERT (NAME) VALUES (:name)", [entity2, entity2])
                # Retrieve the IDs
                cursor.execute("SELECT ID FROM ENTITIES WHERE NAME = :name", [entity1])
                source_id = cursor.fetchone()[0]
                cursor.execute("SELECT ID FROM ENTITIES WHERE NAME = :name", [entity2])
                target_id = cursor.fetchone()[0]
                # Create relations
                cursor.execute("""
                    INSERT INTO RELATIONS (SOURCE_ID, TARGET_ID, RELATION_TYPE, SOURCE_TEXT)
                    VALUES (:src, :tgt, :rel, :txt)
                """, [source_id, target_id, relation, source])
                print(f"✅ {entity1} -[{relation}]-> {entity2}")
            except Exception as e:
                print(f"[INSERT ERROR] {e}")

    oracle_conn.commit()
    cursor.close()
    print("💾 Knowledge graph updated.")

Das Diagrammschema wird mit CREATE PROPERTY GRAPH erstellt, wobei ENTITIES (vertices) und RELATIONS (edges) verknüpft werden.
Verwendet MERGE INTO, um neue Entitys nur einzufügen, wenn sie nicht vorhanden sind (Eindeutigkeit wird sichergestellt).
LLM (Oracle Generative AI) wird verwendet, um Triples des Formulars zu extrahieren Entity1 -[RELATION]-> Entity2.
Alle Interaktionen mit Oracle erfolgen über anonyme oracledb- und PL/SQL-Blöcke.

Jetzt können Sie Folgendes tun:

Mit PGQL können Sie Diagrammbeziehungen untersuchen und abfragen.
Stellen Sie eine Verbindung zu Graph Studio für Visualisierungen her.
Stellen Sie das Diagramm über einen API-REST- oder LangChain-Agent bereit.

Supportfunktionen für Diagrammabfragen

Es gibt zwei wesentliche Funktionen, die semantische Suche und Argumentation über das Knowledge-Diagramm ermöglichen: extract_graph_keywords und query_knowledge_graph. Mit diesen Komponenten können Fragen mithilfe von PGQL in Oracle Autonomous Database in aussagekräftige Diagrammabfragen interpretiert werden.

extract_graph_keywords:

def extract_graph_keywords(question: str) -> str:
    prompt = f"""
    Based on the question below, extract relevant keywords (1 to 2 words per term) that can be used to search for entities and relationships in a technical knowledge graph.

    Question: "{question}"

    Rules:
    - Split compound terms (e.g., "API Gateway" → "API", "Gateway")
    - Remove duplicates
    - Do not include generic words such as: "what", "how", "the", "of", "in the document", etc.
    - Return only the keywords, separated by commas. No explanations.

    Result:
    """
    try:
        resp = llm_for_rag.invoke(prompt)
        keywords_raw = resp.content.strip()

        # Additional post-processing: remove duplicates, normalize
        keywords = {kw.strip().lower() for kw in re.split(r'[,\n]+', keywords_raw)}
        keywords = [kw for kw in keywords if kw]  # remove empty strings
        return ", ".join(sorted(keywords))
    except Exception as e:
        print(f"[KEYWORD EXTRACTION ERROR] {e}")
        return ""

Funktion:

Verwendet ein LLM (llm_for_rag), um Fragen in natürlicher Sprache in eine Liste grafikfreundlicher Schlüsselwörter zu verwandeln.
Der Prompt ist so konzipiert, dass Entitys und Begriffe, die für die Suche im Diagramm relevant sind, sauber extrahiert werden.

Warum es wichtig ist:

Es schließt die Lücke zwischen unstrukturierten Fragen und strukturierten Abfragen.
Stellt sicher, dass nur spezifische, domänenrelevante Begriffe für den Abgleich in der PGQL-Abfrage verwendet werden.

LLM-verbessertes Verhalten:

Bricht zusammengesetzte Fachbegriffe.
Entfernt Stoppwörter (wie was, wie usw.).
Normalisiert Text durch Kleinschreibung und Deduplizierung von Begriffen.

Beispiel:

Eingabe:

"What are the main components of an API Gateway architecture?"

Ausgabeschlüsselwörter:
```
api, gateway, architecture, components
```

query_knowledge_graph:

def query_knowledge_graph(query_text):
    cursor = oracle_conn.cursor()

    sanitized_text = query_text.lower()

    pgql = f"""
        SELECT from_entity,
            relation_type,
            to_entity
        FROM GRAPH_TABLE(
            {GRAPH_NAME}
            MATCH (e1 is ENTITIES)-[r is RELATIONS]->(e2 is ENTITIES)
            WHERE CONTAINS(e1.name, '{sanitized_text}') > 0
            OR CONTAINS(e2.name, '{sanitized_text}') > 0
            OR CONTAINS(r.RELATION_TYPE, '{sanitized_text}') > 0
            COLUMNS (
                e1.name AS from_entity,
                r.RELATION_TYPE AS relation_type,
                e2.name AS to_entity
            )
        )
        FETCH FIRST 20 ROWS ONLY
    """

    print(pgql)

    try:
        cursor.execute(pgql)
        rows = cursor.fetchall()
        if not rows:
            return "⚠️ No relationships found in the graph."

        return "\n".join(f"{r[0]} -[{r[1]}]-> {r[2]}" for r in rows)

    except Exception as e:
        return f"[PGQL ERROR] {e}"

    finally:
        cursor.close()

Funktion:

Akzeptiert eine keyword-basierte Zeichenfolge (oft von extract_graph_keywords erstellt) und erstellt eine PGQL-Abfrage, um Beziehungen aus dem Knowledge-Diagramm abzurufen.

Schlüsselmechanik:

Die GRAPH_TABLE-Klausel verwendet MATCH, um das Diagramm vom Quell- zum Zielknoten zu durchlaufen.
Er verwendet CONTAINS(), um die partielle und Fuzzy-Suche in Knoten-/Edge-Attributen zuzulassen (e1.name, e2.name, r.RELATION_TYPE).
Begrenzt die Ergebnisse auf 20, um eine Überschwemmung der Leistung zu vermeiden.

Warum PGQL verwenden:

PGQL ist SQL-ähnlich, wurde jedoch für den Diagrammdurchlauf entwickelt.
Oracle Autonomous Database unterstützt Eigenschaftsdiagramme, die eine nahtlose Integration zwischen relationalen und Diagrammwelten ermöglichen.
Bietet Funktionen für Indexierung, Optimierung und native Diagrammsuche, die für Unternehmen geeignet sind.

Oracle-spezifische Hinweise:

Die GRAPH_TABLE() ist für Oracle PGQL eindeutig und ermöglicht Abfragen über logische Ansichten von Diagrammen, die über relationale Tabellen definiert werden.
Im Gegensatz zu Cypher (Neo4j) wird PGQL über strukturierte Daten mit SQL-Erweiterungen ausgeführt, was es in RDBMS-lastigen Umgebungen freundlicher macht.

Aufgabe 4: Chatbot ausführen

Führen Sie den folgenden Befehl aus, um den Chatbot auszuführen.

python main.py

Bestätigungen

Autor – Cristiano Hoshikawa (Oracle LAD A, Team Solution Engineer)

Weitere Lernressourcen

Sehen Sie sich weitere Übungen zu docs.oracle.com/learn an, oder greifen Sie auf weitere kostenlose Lerninhalte im Oracle Learning YouTube-Kanal zu. Besuchen Sie außerdem education.oracle.com/learning-explorer, um ein Oracle Learning Explorer zu werden.

Die Produktdokumentation finden Sie im Oracle Help Center.

Titel und Copyright-Informationen

Create a Knowledge Graph with Oracle Autonomous Database and Property Graph Query Language

G38831-02