Intro
In der Informatik gibt es wie in der menschlichen Wahrnehmung verschiedene Speicherebenen:
- Primärgedächtnis (Wie RAM) ist der aktive temporäre Speicher, der für aktuelle Aufgaben, Argumentation und Entscheidungsfindung bei aktuellen Aufgaben verwendet wird. Es enthält die Informationen, mit denen Sie derzeit arbeiten. Es ist Schnell, aber volatilwas bedeutet, dass es Daten verliert, wenn die Leistung ausgeschaltet ist.
- Sekundärgedächtnis (wie physische Speicherung) bezieht sich auf eine langfristige Speicherung von erlerntem Wissen, das im Arbeitsgedächtnis nicht sofort aktiv ist. Es wird bei der Entscheidungsfindung in Echtzeit nicht immer zugegriffen, kann jedoch bei Bedarf abgerufen werden. Deshalb ist es langsamer, aber anhaltender.
- Tertiärspeicher (wie die Sicherung historischer Daten) bezieht sich auf das Archivgedächtnis, bei dem Informationen zu Sicherungszwecken und zur Katastrophenwiederherstellung gespeichert werden. Es ist charakterisiert von hohe Kapazität und niedrige Kosten, aber mit langsamer Zugriffszeit. Folglich wird es selten verwendet.
AI -Agenten können alle Speichertypen nutzen. Erstens können sie den primären Speicher verwenden, um Ihre aktuelle Frage zu bearbeiten. Dann würden sie auf ein sekundäres Gedächtnis zugreifen, um Wissen aus jüngsten Gesprächen einzubringen. Und bei Bedarf können sie sogar ältere Informationen aus dem tertiären Speicher abrufen.
In diesem Tutorial werde ich zeigen, wie es geht Erstellen Sie einen AI -Agenten mit Speicher über mehrere Sitzungen hinweg. Ich werde einen nützlichen Python -Code präsentieren, der in ähnlichen Fällen leicht angewendet werden kann (einfach kopieren, einfügen, einfügen) und jede Codezeile mit Kommentaren durchgehen, damit Sie dieses Beispiel replizieren können (Hyperlink zum vollständigen Code am Ende des Artikels).
Aufstellen
Beginnen wir mit der Einrichtung Ollama (pip set up ollama==0.5.1), eine Bibliothek, mit der Benutzer Open-Supply LLMs lokal ausführen können, ohne Cloud-basierte Dienste zu benötigen, um mehr Kontrolle über Datenschutz und Leistung zu erhalten. Da es lokal ausgeführt wird, verlassen alle Konversationsdaten Ihren Laptop nicht.
Zuallererst müssen Sie herunterladen Ollama von der Web site.
Verwenden Sie dann auf der Eingabeaufforderung Ihres Laptops den Befehl, um das ausgewählte LLM herunterzuladen. Ich gehe mit Alibaba’s Qwenwie es sowohl klug als auch hell ist.
Nach Abschluss des Downloads können Sie zu Python übergehen und Code schreiben.
import ollama
llm = "qwen2.5"Testen wir die LLM:
stream = ollama.generate(mannequin=llm, immediate='''what time is it?''', stream=True)
for chunk in stream:
print(chunk('response'), finish='', flush=True)
Datenbank
Ein Agent mit Multi-Session-Speicher ist ein künstliches Intelligenzsystem, das kann Denken Sie an Informationen von einer Interaktion zur nächstenauch wenn diese Interaktionen zu unterschiedlichen Zeiten oder über getrennte Sitzungen auftreten. Zum Beispiel eine persönliche Assistentin, die sich an Ihren Tagesplan und Ihre Vorlieben erinnert, oder an einen Bot für Kundenunterstützung, der Ihre Ausgabehistorie kennt, ohne dass Sie sich jedes Mal erneut erklären müssen.
Grundsätzlich muss der Agent auf den Chat -Verlauf zugreifen. Basierend darauf, wie alt die vergangenen Gespräche sind, kann dies als sekundärer oder tertiärer Speicher eingestuft werden.
Kommen wir zur Arbeit. Wir können Gesprächsdaten in einem speichern VektordatenbankDies ist die beste Lösung, um unstrukturierte Daten effizient zu speichern, zu indizieren und zu durchsuchen. Derzeit ist der am häufigsten verwendete Vektor DB Microsoft’s AiSearchwährend der beste Open-Supply- Chromadbwas nützlich, einfach und kostenlos ist.
Nach einem schnellen pip set up chromadb==0.5.23 Sie können mit der DB mit Python in interagieren Drei verschiedene Arten:
chromadb.Consumer()Um eine DB zu schaffen, die vorübergehend im Gedächtnis bleibt, ohne den physischen Raum auf der Festplatte zu besetzen.chromadb.PersistentClient(path)Um die DB von Ihrer lokalen Maschine zu speichern und zu laden.chromadb.HttpClient(host='localhost', port=8000)Um einen Consumer-Server-Modus in Ihrem Browser zu haben.
Beim Speichern von Dokumenten in ChromadbDaten werden als Vektoren gespeichert, sodass man mit einem Abfragevektor suchen kann, um die nächsten Übereinstimmungsdatensätze abzurufen. Bitte beachten Sie, dass die Standardeinbettungsfunktion, falls dies nicht angegeben ist, a ist Satztransformator Modell (All-Minilm-L6-V2).
import chromadb
## hook up with db
db = chromadb.PersistentClient()
## verify current collections
db.list_collections()
## choose a group
collection_name = "chat_history"
assortment = db.get_or_create_collection(identify=collection_name,
embedding_function=chromadb.utils.embedding_functions.DefaultEmbeddingFunction())Um Ihre Daten zu speichern, müssen Sie zunächst benötigen Extrahieren Sie den Chat und speichern Sie es als ein Textdokument. In Ollamaes gibt 3 Rollen in der Interaktion mit einem LLM:
- System – Wird verwendet, um Kernanweisungen an das Modell zu übergeben, wie das Gespräch fortgesetzt werden soll (dh die Hauptaufforderung)
- Benutzer – Wird für die Fragen des Benutzers und auch für die Speicherverstärkung verwendet (dh „Denken Sie daran, dass die Antwort ein bestimmtes Format haben muss“).
- Assistent – Es ist die Antwort aus dem Modell (dh die endgültige Antwort)
Stellen Sie sicher, dass jedes Dokument über eine eindeutige ID verfügt, die Sie manuell generieren oder zulassen können Chroma automatisch generieren. Eine wichtige Sache zu erwähnen ist, dass Sie zusätzliche Informationen als Metadaten hinzufügen können (dh Titel, Tags, Hyperlinks). Es ist elective, aber sehr nützlich wie Metadatenanreicherung kann das Abrufen von Dokumenten erheblich verbessern. Zum Beispiel werde ich hier das LLM verwenden, um jedes Dokument in einige Schlüsselwörter zusammenzufassen.
from datetime import datetime
def save_chat(lst_msg, assortment):
print("--- Saving Chat ---")
## extract chat
chat = ""
for m in lst_msg:
chat += f'{m("position")}: <<{m("content material")}>>' +'nn'
## get idx
idx = str(assortment.rely() +1)
## generate information
p = "Describe the next dialog utilizing solely 3 key phrases separated by a comma (for instance: 'finance, volatility, shares')."
tags = ollama.generate(mannequin=llm, immediate=p+"n"+chat)("response")
dic_info = {"tags":tags,
"date": datetime.immediately().strftime("%Y-%m-%d"),
"time": datetime.immediately().strftime("%H:%M")}
## write db
assortment.add(paperwork=(chat), ids=(idx), metadatas=(dic_info))
print(f"--- Chat num {idx} saved ---","n")
print(dic_info,"n")
print(chat)
print("------------------------")Wir müssen anfangen und einen Chat speichern, um es in Aktion zu sehen.
Fundamental Agent ausführen
Zunächst werde ich einen sehr einfachen LLM -Chat ausführen (keine Instruments erforderlich), um die erste Konversation in der Datenbank zu speichern. Während der Interaktion werde ich einige wichtige Informationen erwähnen, die nicht in der LLM -Wissensbasis enthalten sind, an die sich der Agent in der nächsten Sitzung erinnern soll.
immediate = "You might be an clever assistant, present the very best reply to consumer's request."
messages = ({"position":"system", "content material":immediate})
whereas True:
## Person
q = enter('🙂 >')
if q == "stop":
### save chat earlier than quitting
save_chat(lst_msg=messages, assortment=assortment)
break
messages.append( {"position":"consumer", "content material":q} )
## Mannequin
agent_res = ollama.chat(mannequin=llm, messages=messages, instruments=())
res = agent_res("message")("content material")
## Response
print("👽 >", f"x1b(1;30m{res}x1b(0m")
messages.append( {"position":"assistant", "content material":res} )
Am Ende wurde das Gespräch mit angereicherten Metadaten gerettet.
Werkzeuge
Ich möchte, dass der Agent Informationen aus früheren Gesprächen abrufen kann. Daher muss ich es dazu ein Werkzeug zur Verfügung stellen. Um es anders auszudrücken, muss der Agent a tun REMAINAL-AUGENTED-Technology (LAG) aus der Geschichte. Es ist eine Technik, die Abruf- und Generativmodelle kombiniert, indem LLMS -Wissensfakten hinzugefügt werden, die aus externen Quellen hergestellt wurden (in diesem Fall, Chromadb).
def retrieve_chat(question:str) -> str:
res_db = assortment.question(query_texts=(question))("paperwork")(0)(0:10)
historical past = ' '.be part of(res_db).change("n", " ")
return historical past
tool_retrieve_chat = {'sort':'perform', 'perform':{
'identify': 'retrieve_chat',
'description': 'Whenever you data is NOT sufficient to reply the consumer, you need to use this device to retrieve chats historical past.',
'parameters': {'sort': 'object',
'required': ('question'),
'properties': {
'question': {'sort':'str', 'description':'Enter the consumer query or the subject of the present chat'},
}}}}Nach dem Abholen von Daten muss die KI alle Informationen verarbeiten und dem Benutzer die endgültige Antwort geben. Manchmal kann es wirksamer sein, die zu behandeln „Endgültige Antwort“ als Werkzeug. Wenn der Agent beispielsweise mehrere Aktionen ausführt, um Zwischenergebnisse zu generieren, kann die endgültige Antwort als das Software betrachtet werden, das alle diese Informationen in eine zusammenhängende Antwort integriert. Indem Sie es so entwerfen, haben Sie mehr Anpassungen und Kontrolle über die Ergebnisse.
def final_answer(textual content:str) -> str:
return textual content
tool_final_answer = {'sort':'perform', 'perform':{
'identify': 'final_answer',
'description': 'Returns a pure language response to the consumer',
'parameters': {'sort': 'object',
'required': ('textual content'),
'properties': {'textual content': {'sort':'str', 'description':'pure language response'}}
}}}Wir sind endlich bereit, den Agenten und seinen Speicher zu testen.
dic_tools = {'retrieve_chat':retrieve_chat,
'final_answer':final_answer}Run Agent mit Speicher
Ich werde ein paar hinzufügen Utils Funktionen für die Werkzeugverwendung und für das Ausführen des Agenten.
def use_tool(agent_res:dict, dic_tools:dict) -> dict:
## use device
if agent_res("message").tool_calls isn't None:
for device in agent_res("message").tool_calls:
t_name, t_inputs = device("perform")("identify"), device("perform")("arguments")
if f := dic_tools.get(t_name):
### calling device
print('🔧 >', f"x1b(1;31m{t_name} -> Inputs: {t_inputs}x1b(0m")
### device output
t_output = f(**device("perform")("arguments"))
print(t_output)
### ultimate res
res = t_output
else:
print('🤬 >', f"x1b(1;31m{t_name} -> NotFoundx1b(0m")
## do not use device
else:
res = agent_res("message").content material
t_name, t_inputs = '', ''
return {'res':res, 'tool_used':t_name, 'inputs_used':t_inputs}Wenn der Agent versucht, eine Aufgabe zu lösen, möchte ich die verwendeten Instruments und die erzielten Ergebnisse verfolgen. Das Modell sollte jedes Werkzeug nur einmal versuchen, und die Iteration soll nur aufhören, wenn der Agent bereit ist, die endgültige Antwort zu geben.
def run_agent(llm, messages, available_tools):
## use instruments till ultimate reply
tool_used, local_memory = '', ''
whereas tool_used != 'final_answer':
### use device
attempt:
agent_res = ollama.chat(mannequin=llm, messages=messages, instruments=(v for v in available_tools.values()))
dic_res = use_tool(agent_res, dic_tools)
res, tool_used, inputs_used = dic_res("res"), dic_res("tool_used"), dic_res("inputs_used")
### error
besides Exception as e:
print("⚠️ >", e)
res = f"I attempted to make use of {tool_used} however did not work. I'll attempt one thing else."
print("👽 >", f"x1b(1;30m{res}x1b(0m")
messages.append( {"position":"assistant", "content material":res} )
### replace reminiscence
if tool_used not in ('','final_answer'):
local_memory += f"n{res}"
messages.append( {"position":"consumer", "content material":local_memory} )
available_tools.pop(tool_used)
if len(available_tools) == 1:
messages.append( {"position":"consumer", "content material":"now activate the device final_answer."} )
### instruments not used
if tool_used == '':
break
return resLassen Sie uns eine neue Interaktion beginnen, und diesmal möchte ich, dass der Agent alle Instruments aktiviert, um alte Informationen zu ärgern und zu verarbeiten.
immediate = '''
You might be an clever assistant, present the very best reply to consumer's request.
You have to return pure language response.
When interacting with a consumer, first you will need to use the device 'retrieve_chat' to recollect earlier chats historical past.
'''
messages = ({"position":"system", "content material":immediate})
whereas True:
## Person
q = enter('🙂 >')
if q == "stop":
### save chat earlier than quitting
save_chat(lst_msg=messages, assortment=assortment)
break
messages.append( {"position":"consumer", "content material":q} )
## Mannequin
available_tools = {"retrieve_chat":tool_retrieve_chat, "final_answer":tool_final_answer}
res = run_agent(llm, messages, available_tools)
## Response
print("👽 >", f"x1b(1;30m{res}x1b(0m")
messages.append( {"position":"assistant", "content material":res} )
Ich gab dem Agenten eine Aufgabe, die nicht direkt mit dem Thema der letzten Sitzung korrelierte. Wie erwartet aktivierte der Agent das Software und untersuchte frühere Chats. Jetzt wird die „endgültige Antwort“ verwendet, um die Informationen zu verarbeiten und auf mich zu antworten.
Abschluss
Dieser Artikel battle ein Tutorial, um nachzuweisen So bauen Sie KI-Agenten mit Multi-Session-Speicher von Grund auf neu auf Ollama. Mit diesen Bausteinen sind Sie bereits ausgestattet, um Ihre eigenen Agenten für verschiedene Anwendungsfälle zu entwickeln.
Voller Code für diesen Artikel: Github
Ich hoffe es hat dir gefallen! Wenden Sie sich an mich, um mich für Fragen und Suggestions zu kontaktieren oder einfach Ihre interessanten Projekte zu teilen.
👉 Lassen Sie uns eine Verbindung herstellen 👈
(Alle Bilder, sofern nicht anders angegeben, werden vom Autor)