Oracle AI Database lokal ausführen

In diesem Artikel wird gezeigt, wie Sie Oracle AI Database lokal mit Docker oder Podman ausführen und oracleagentmemory mit dieser Datenbank verbinden.

In diesem Artikel erfahren Sie, wie Sie:

Oracle AI Database mit Docker oder Podman abrufen und starten.
Erstellen Sie optional einen lokalen Oracle-Benutzer und Tablespace für oracleagentmemory.
Konfigurieren Sie eine von Oracle unterstützte oracleagentmemory-API mit LiteLLM-Einbettung und LLM-Adaptern.
Vergewissern Sie sich, dass die Datensätze beibehalten werden, indem Sie denselben Thread über eine zweite API-Instanz erneut öffnen.

Voraussetzungen

Installieren Sie Docker oder Podman, und stellen Sie sicher, dass die entsprechende CLI in der Shell verfügbar ist. Rufen Sie dann das Oracle AI Database Free Lite-Image aus der Oracle Container-Registry ab.

Wählen Sie ein sicheres Kennwort für den Oracle SYSTEM-Benutzer, und exportieren Sie es, bevor Sie den Container starten:

export ORACLE_PWD='<your-secure-password>'

Docker:

docker pull container-registry.oracle.com/database/free:latest-lite

Podman:

podman pull container-registry.oracle.com/database/free:latest-lite

Oracle AI Database Container starten

Erstellen Sie ein benanntes Volume, damit die Datenbankdateien auch nach einem Neustart beibehalten werden:

Docker:

docker volume create OracleDBData

Podman:

podman volume create OracleDBData

Starten Sie dann den Container:

Docker:

docker run -d \
  --name oracle-free-lite \
  -p 1521:1521 \
  -e ORACLE_PWD="$ORACLE_PWD" \
  -v OracleDBData:/opt/oracle/oradata \
  container-registry.oracle.com/database/free:latest-lite

Podman:

podman run -d \
  --name oracle-free-lite \
  -p 1521:1521 \
  -e ORACLE_PWD="$ORACLE_PWD" \
  -v OracleDBData:/opt/oracle/oradata \
  container-registry.oracle.com/database/free:latest-lite

Hinweis: Wenn Podman Probleme mit der SELinux-Labeling in RHEL hat, können Sie die Konfigurationsparameter security-opt prüfen.

Folgen Sie dann dem Container-Log, bis die Datenbank meldet, dass sie bereit ist.

Docker:

docker logs -f oracle-free-lite

Podman:

podman logs -f oracle-free-lite

Wenn das Log DATABASE IS READY TO USE! enthält, sind der Listener und die integrierbare Standarddatenbank hochgefahren.

Wenn die Datenbank bereit ist, melden Sie sich bei der Datenbank an.

Docker:

docker exec -it oracle-free-lite sqlplus system/"$ORACLE_PWD"@FREEPDB1

Podman:

podman exec -it oracle-free-lite sqlplus system/"$ORACLE_PWD"@FREEPDB1

Führen Sie eine einfache Abfrage aus dem Container aus, um zu bestätigen, dass die PDB geöffnet ist.

SELECT sys_context('USERENV', 'CON_NAME') AS container_name FROM dual;

Es sollte FREEPDB1 angezeigt werden.

Geben Sie dann exit ein, und drücken Sie Enter, um SQL*Plus zu verlassen.

[Optional] Lokalen Oracle-Benutzer erstellen

Wenn Sie bereits eine Oracle AI Database und einen Anwendungsbenutzer haben, überspringen Sie diesen Abschnitt, und fahren Sie mit dem nächsten Abschnitt fort: Testen Sie oracleagentmemory für die lokale Datenbank. Eine kürzere Schritt-für-Schritt-Anleitung zur API selbst finden Sie unter Speicher für einen Benutzer speichern und suchen.

Das Beispielskript in diesem Artikel verwendet einen dedizierten lokalen Datenbankbenutzer:

DB_USER = os.environ.get("ORACLE_MEMORY_DB_USER", "dmuser")
DB_PASSWORD = os.environ["ORACLE_MEMORY_DB_PASSWORD"]
DB_CONNECT_STRING = os.environ.get(
    "ORACLE_MEMORY_DB_CONNECT_STRING",
    "localhost:1521/FREEPDB1",
)

Wählen Sie ein sicheres Passwort für diesen Anwendungsbenutzer, und exportieren Sie es, bevor Sie das Skript ausführen:

export ORACLE_MEMORY_DB_PASSWORD='<your-app-user-password>'

Erstellen Sie dann den Benutzer innerhalb der PDB:

Docker:

docker exec -it oracle-free-lite sqlplus system/"$ORACLE_PWD"@FREEPDB1

Podman:

podman exec -it oracle-free-lite sqlplus system/"$ORACLE_PWD"@FREEPDB1

CREATE TABLESPACE dmuser_ts
DATAFILE '/opt/oracle/oradata/FREE/FREEPDB1/dmuser_ts01.dbf'
SIZE 200M
AUTOEXTEND ON NEXT 100M
SEGMENT SPACE MANAGEMENT AUTO;

CREATE USER dmuser IDENTIFIED BY "CHOOSE_A_STRONG_PASSWORD";
GRANT CREATE SESSION, CREATE TABLE, CREATE SEQUENCE, CREATE VIEW, CREATE PROCEDURE TO dmuser;
ALTER USER dmuser DEFAULT TABLESPACE dmuser_ts;
ALTER USER dmuser QUOTA UNLIMITED ON dmuser_ts;

Ersetzen Sie CHOOSE_A_STRONG_PASSWORD durch denselben Kennwortwert, den Sie in ORACLE_MEMORY_DB_PASSWORD speichern.

Prüfen Sie anschließend, ob der Benutzer bereit ist:

SELECT tablespace_name, contents
FROM dba_tablespaces
WHERE tablespace_name = 'DMUSER_TS';

SELECT username, account_status, default_tablespace, temporary_tablespace
FROM dba_users
WHERE username = 'DMUSER';

SELECT privilege
FROM dba_sys_privs
WHERE grantee = 'DMUSER'
ORDER BY privilege;

Bei der ersten Abfrage sollte DMUSER_TS als permanenter Tablespace angezeigt werden. In der zweiten Abfrage muss DMUSER mit dem Status OPEN und DMUSER_TS als Standard-Tablespace angezeigt werden. Die Berechtigungsabfrage muss mindestens CREATE SESSION, CREATE TABLE, CREATE SEQUENCE, CREATE VIEW und CREATE PROCEDURE enthalten.

oracleagentmemory mit lokaler Datenbank testen

Nachdem Ihre Oracle-Verbindungseinstellungen bereit sind, können Sie auf oracleagentmemory unter FREEPDB1 verweisen und eine kleine End-to-End-Persistenzprüfung ausführen.

Das folgende Beispiel führt zwei Dinge aus:

Es erstellt eine erste Agent-Speicher-API-Instanz, die Nachrichten und Speicher schreibt.
Es erstellt eine zweite Agent Memory API-Instanz, die denselben Thread erneut öffnet und von Oracle abfragt.

Legen Sie die Anwendungsverbindungsvariablen fest, bevor Sie das Beispiel ausführen. Der Benutzer und die unten gezeigte Verbindungszeichenfolge stimmen mit dem vorherigen optionalen Setup überein. Sie können sie jedoch durch Ihren eigenen vorhandenen Oracle-Benutzer und DSN ersetzen:

export ORACLE_MEMORY_DB_USER='dmuser'
export ORACLE_MEMORY_DB_PASSWORD='<your-app-user-password>'
export ORACLE_MEMORY_DB_CONNECT_STRING='localhost:1521/FREEPDB1'

Von Oracle unterstützte API konfigurieren

import os

os.environ["LITELLM_LOCAL_MODEL_COST_MAP"] = "True"

import oracledb

from oracleagentmemory.core import OracleAgentMemory, SchemaPolicy
from oracleagentmemory.core.embedders.embedder import Embedder
from oracleagentmemory.core.llms.llm import Llm


embedder = Embedder(
    model="YOUR_EMBEDDING_MODEL",
    api_base="YOUR_EMBEDDING_API_BASE",
    api_key="YOUR_EMBEDDING_API_KEY",
)
llm = Llm(
    model="YOUR_LLM_MODEL",
    api_base="YOUR_LLM_API_BASE",
    api_key="YOUR_LLM_API_KEY",
)


DB_USER = os.environ.get("ORACLE_MEMORY_DB_USER", "dmuser")
DB_PASSWORD = os.environ["ORACLE_MEMORY_DB_PASSWORD"]
DB_CONNECT_STRING = os.environ.get("ORACLE_MEMORY_DB_CONNECT_STRING", "localhost:1521/FREEPDB1")
TABLE_NAME_PREFIX = "T_ORACLEMEM_DEMO_"

db_pool = oracledb.SessionPool(
    user=DB_USER,
    password=DB_PASSWORD,
    dsn=DB_CONNECT_STRING,
    min=1,
    max=4,
    increment=1,
    homogeneous=True,
)

agent_memory = OracleAgentMemory(
    connection=db_pool,
    embedder=embedder,
    llm=llm,
    schema_policy=SchemaPolicy.RECREATE,
    table_name_prefix=TABLE_NAME_PREFIX,
)

Diese Konfiguration verwendet die lokale Oracle AI Database zusammen mit den Platzhalter-LiteLLM-Einbettungs- und Abschlusseinstellungen, die Sie durch Ihre eigenen Providerwerte ersetzen können.

Datensätze schreiben und Persistenz prüfen

#Keep the same user identifier for the same end user across sessions
#so durable memory can be retrieved consistently.
user_id = "user_123"

thread = agent_memory.create_thread(user_id=user_id)
thread.add_messages(
    [
        {
            "role": "user",
            "content": "Orange juice is my usual breakfast drink.",
        },
        {
            "role": "assistant",
            "content": "Pair it with eggs, toast, or Greek yogurt.",
        },
    ]
)
thread.add_memory("The user currently prefers orange juice with breakfast.")

db_pool2 = oracledb.SessionPool(
    user=DB_USER,
    password=DB_PASSWORD,
    dsn=DB_CONNECT_STRING,
    min=1,
    max=4,
    increment=1,
    homogeneous=True,
)

agent_memory2 = OracleAgentMemory(
    connection=db_pool2,
    embedder=embedder,
    llm=llm,
    schema_policy=SchemaPolicy.REQUIRE_EXISTING,
    table_name_prefix=TABLE_NAME_PREFIX,
)
persisted_thread = agent_memory2.get_thread(thread.thread_id)

print("Messages stored in Oracle:")
print_messages(persisted_thread.get_messages())

print("\nSearch results for 'orange juice':")
print_search_results(
    agent_memory2.search(
        query="orange juice",
        user_id=user_id,
        max_results=5,
        record_types=["memory", "message"],
    )
)

Wenn dieses Beispiel erfolgreich ausgeführt wird, druckt die zweite Agent-Speicher-API-Instanz die gespeicherten Threadnachrichten und gibt Suchergebnisse aus der Datenbank zurück. Dadurch wird bestätigt, dass die Datensätze in Oracle beibehalten wurden und nicht nur im Prozessspeicher gespeichert wurden.

Bereinigen

Wenn Sie mit der lokalen Datenbank fertig sind:

Docker:

docker stop oracle-free-lite
docker rm oracle-free-lite

Podman:

podman stop oracle-free-lite
podman rm oracle-free-lite

Wenn Sie auch die persistenten Datenbankdateien löschen möchten:

Docker:

docker volume rm OracleDBData

Podman:

podman volume rm OracleDBData

Schlussfolgerung

In diesem Artikel haben wir gelernt, wie Sie Oracle AI Database Free Lite lokal mit Docker oder Podman starten, einen dedizierten Oracle-Benutzer und Tablespace für oracleagentmemory vorbereiten, eine oracleagentmemory-API mit dieser Datenbank verbinden und die Persistenz prüfen, indem Sie denselben Thread über eine separate API-Instanz erneut öffnen und durchsuchen.

Tipp: Nachdem Sie gelernt haben, wie Sie oracleagentmemory für eine lokale Oracle AI Database ausführen, können Sie jetzt mit Speicher und Arbeitsspeicher für einen Benutzer speichern fortfahren.

Vollständiger Code

#Copyright © 2026 Oracle and/or its affiliates.
#isort:skip_file
#fmt: off
#%%[markdown]
#Agent Memory Code Example - Run Oracle DB locally
#--------------------------------------------------------


#How to use:
#Create a new Python virtual environment and install the latest oracleagentmemory version.

#You can now run the script
#1. As a Python file:
#```bash
#python howto_run_oracledb.py
#```
#2. As a Notebook (in VSCode):
#When viewing the file,
#- press the keys Ctrl + Enter to run the selected cell
#- or Shift + Enter to run the selected cell and move to the cell below


##Configure the local Oracle connection

#%%
import os

os.environ["LITELLM_LOCAL_MODEL_COST_MAP"] = "True"

import oracledb

from oracleagentmemory.core import OracleAgentMemory, SchemaPolicy
from oracleagentmemory.core.embedders.embedder import Embedder
from oracleagentmemory.core.llms.llm import Llm


embedder = Embedder(
    model="YOUR_EMBEDDING_MODEL",
    api_base="YOUR_EMBEDDING_API_BASE",
    api_key="YOUR_EMBEDDING_API_KEY",
)
llm = Llm(
    model="YOUR_LLM_MODEL",
    api_base="YOUR_LLM_API_BASE",
    api_key="YOUR_LLM_API_KEY",
)


DB_USER = os.environ.get("ORACLE_MEMORY_DB_USER", "dmuser")
DB_PASSWORD = os.environ["ORACLE_MEMORY_DB_PASSWORD"]
DB_CONNECT_STRING = os.environ.get("ORACLE_MEMORY_DB_CONNECT_STRING", "localhost:1521/FREEPDB1")
TABLE_NAME_PREFIX = "T_ORACLEMEM_DEMO_"

db_pool = oracledb.SessionPool(
    user=DB_USER,
    password=DB_PASSWORD,
    dsn=DB_CONNECT_STRING,
    min=1,
    max=4,
    increment=1,
    homogeneous=True,
)

agent_memory = OracleAgentMemory(
    connection=db_pool,
    embedder=embedder,
    llm=llm,
    schema_policy=SchemaPolicy.RECREATE,
    table_name_prefix=TABLE_NAME_PREFIX,
)


def print_messages(messages: list) -> None:
    for message in messages:
        print(f"[{message.role}] {message.content}")


def print_search_results(results: list) -> None:
    for result in results:
        print(
            f"- [{result.record.record_type}] "
            f"id={result.id} "
            f"user_id={result.record.user_id} "
            f"thread_id={result.record.thread_id} "
            f"content={result.content}"
        )


##Create data and query it

#%%
#Keep the same user identifier for the same end user across sessions so
#durable memory can be retrieved consistently.
user_id = "user_123"

thread = agent_memory.create_thread(user_id=user_id)
#add_messages will add messages to the DB and extract memories automatically
thread.add_messages(
    [
        {
            "role": "user",
            "content": "Orange juice is my usual breakfast drink.",
        },
        {
            "role": "assistant",
            "content": "Pair it with eggs, toast, or Greek yogurt.",
        },
    ]
)
#add_memory adds memory to the DB
thread.add_memory("The user currently prefers orange juice with breakfast.")

db_pool2 = oracledb.SessionPool(
    user=DB_USER,
    password=DB_PASSWORD,
    dsn=DB_CONNECT_STRING,
    min=1,
    max=4,
    increment=1,
    homogeneous=True,
)

agent_memory2 = OracleAgentMemory(
    connection=db_pool2,
    embedder=embedder,
    llm=llm,
    schema_policy=SchemaPolicy.REQUIRE_EXISTING,
    table_name_prefix=TABLE_NAME_PREFIX,
)
persisted_thread = agent_memory2.get_thread(thread.thread_id)

print("Messages stored in Oracle:")
print_messages(persisted_thread.get_messages())

print("\nSearch results for 'orange juice':")
print_search_results(
    agent_memory2.search(
        query="orange juice",
        user_id=user_id,
        max_results=5,
        record_types=["memory", "message"],
    )
)