langchainrb
0.19.2
⚡ Erstellen von LLM-basierten Anwendungen in Ruby ⚡
Für eine tiefe Rails-Integration siehe: langchainrb_rails gem.
Verfügbar für kostenpflichtige Beratungsaufträge! Schicken Sie mir eine E-Mail.
Installieren Sie das Gem und fügen Sie es der Gemfile der Anwendung hinzu, indem Sie Folgendes ausführen:
bundle add langchainrb
Wenn der Bundler nicht zum Verwalten von Abhängigkeiten verwendet wird, installieren Sie das Gem, indem Sie Folgendes ausführen:
gem install langchainrb
Möglicherweise sind zusätzliche Edelsteine erforderlich. Sie sind nicht standardmäßig enthalten, sodass Sie nur das hinzufügen können, was Sie benötigen.
require "langchain" Das Langchain::LLM -Modul bietet eine einheitliche Schnittstelle für die Interaktion mit verschiedenen Large Language Model (LLM)-Anbietern. Diese Abstraktion ermöglicht Ihnen den einfachen Wechsel zwischen verschiedenen LLM-Backends, ohne Ihren Anwendungscode zu ändern.
Alle LLM-Klassen erben von Langchain::LLM::Base und bieten eine konsistente Schnittstelle für allgemeine Vorgänge:
Die meisten LLM-Klassen können mit einem API-Schlüssel und optionalen Standardoptionen initialisiert werden:
llm = Langchain :: LLM :: OpenAI . new (
api_key : ENV [ "OPENAI_API_KEY" ] ,
default_options : { temperature : 0.7 , chat_model : "gpt-4o" }
) Verwenden Sie die embed -Methode, um Einbettungen für einen bestimmten Text zu generieren:
response = llm . embed ( text : "Hello, world!" )
embedding = response . embedding embed()text : (Erforderlich) Der einzubettende Eingabetext.model : (Optional) Der zu verwendende Modellname oder das standardmäßige Einbettungsmodell wird verwendet. Verwenden Sie die Methode complete “, um Vervollständigungen für eine bestimmte Eingabeaufforderung zu generieren:
response = llm . complete ( prompt : "Once upon a time" )
completion = response . completion complete()prompt : (Erforderlich) Die Eingabeaufforderung zur Vervollständigung.max_tokens : (Optional) Die maximale Anzahl der zu generierenden Token.temperature : (Optional) Steuert die Zufälligkeit bei der Generierung. Höhere Werte (z. B. 0,8) machen die Ausgabe zufälliger, während niedrigere Werte (z. B. 0,2) sie deterministischer machen.top_p : (Optional) Eine Alternative zur Temperatur, steuert die Vielfalt der generierten Token.n : (Optional) Anzahl der Vervollständigungen, die für jede Eingabeaufforderung generiert werden sollen.stop : (Optional) Sequenzen, in denen die API die Generierung weiterer Token stoppt.presence_penalty : (Optional) Bestraft neue Token basierend auf ihrer bisherigen Präsenz im Text.frequency_penalty : (Optional) Bestraft neue Token basierend auf ihrer bisherigen Häufigkeit im Text. Verwenden Sie die chat -Methode, um Chat-Abschlüsse zu generieren:
messages = [
{ role : "system" , content : "You are a helpful assistant." } ,
{ role : "user" , content : "What's the weather like today?" }
# Google Gemini and Google VertexAI expect messages in a different format:
# { role: "user", parts: [{ text: "why is the sky blue?" }]}
]
response = llm . chat ( messages : messages )
chat_completion = response . chat_completion chat()messages : (Erforderlich) Ein Array von Nachrichtenobjekten, die den Konversationsverlauf darstellen.model : (Optional) Das spezifische Chat-Modell, das verwendet werden soll.temperature : (Optional) Steuert die Zufälligkeit bei der Generierung.top_p : (Optional) Eine Alternative zur Temperatur, steuert die Vielfalt der generierten Token.n : (Optional) Anzahl der zu generierenden Chat-Abschlussoptionen.max_tokens : (Optional) Die maximale Anzahl an Token, die beim Chat-Abschluss generiert werden sollen.stop : (Optional) Sequenzen, in denen die API die Generierung weiterer Token stoppt.presence_penalty : (Optional) Bestraft neue Token basierend auf ihrer bisherigen Präsenz im Text.frequency_penalty : (Optional) Bestraft neue Token basierend auf ihrer bisherigen Häufigkeit im Text.logit_bias : (Optional) Ändert die Wahrscheinlichkeit, dass bestimmte Token in der Vervollständigung erscheinen.user : (Optional) Eine eindeutige Kennung, die Ihren Endbenutzer darstellt.tools : (Optional) Eine Liste der Tools, die das Modell aufrufen kann.tool_choice : (Optional) Steuert, wie das Modell Funktionen aufruft. Dank der einheitlichen Schnittstelle können Sie problemlos zwischen verschiedenen LLM-Anbietern wechseln, indem Sie die von Ihnen instanziierte Klasse ändern:
# Using Anthropic
anthropic_llm = Langchain :: LLM :: Anthropic . new ( api_key : ENV [ "ANTHROPIC_API_KEY" ] )
# Using Google Gemini
gemini_llm = Langchain :: LLM :: GoogleGemini . new ( api_key : ENV [ "GOOGLE_GEMINI_API_KEY" ] )
# Using OpenAI
openai_llm = Langchain :: LLM :: OpenAI . new ( api_key : ENV [ "OPENAI_API_KEY" ] ) Jede LLM-Methode gibt ein Antwortobjekt zurück, das eine konsistente Schnittstelle für den Zugriff auf die Ergebnisse bereitstellt:
embedding : Gibt den Einbettungsvektor zurückcompletion : Gibt die generierte Textvervollständigung zurückchat_completion : Gibt den generierten Chat-Abschluss zurücktool_calls : Gibt vom LLM durchgeführte Werkzeugaufrufe zurückprompt_tokens : Gibt die Anzahl der Token in der Eingabeaufforderung zurückcompletion_tokens : Gibt die Anzahl der Token in der Vervollständigung zurücktotal_tokens : Gibt die Gesamtzahl der verwendeten Token zurück Notiz
Während die Kernschnittstelle bei allen Anbietern konsistent ist, bieten einige LLMs möglicherweise zusätzliche Funktionen oder Parameter. Konsultieren Sie die Dokumentation für jede LLM-Klasse, um mehr über anbieterspezifische Funktionen und Optionen zu erfahren.
Erstellen Sie eine Eingabeaufforderung mit Eingabevariablen:
prompt = Langchain :: Prompt :: PromptTemplate . new ( template : "Tell me a {adjective} joke about {content}." , input_variables : [ "adjective" , "content" ] )
prompt . format ( adjective : "funny" , content : "chickens" ) # "Tell me a funny joke about chickens."Erstellen einer PromptTemplate nur mit einer Eingabeaufforderung und ohne Eingabevariablen:
prompt = Langchain :: Prompt :: PromptTemplate . from_template ( "Tell me a funny joke about chickens." )
prompt . input_variables # []
prompt . format # "Tell me a funny joke about chickens."Eingabeaufforderungsvorlage in JSON-Datei speichern:
prompt . save ( file_path : "spec/fixtures/prompt/prompt_template.json" )Laden einer neuen Eingabeaufforderungsvorlage mithilfe einer JSON-Datei:
prompt = Langchain :: Prompt . load_from_path ( file_path : "spec/fixtures/prompt/prompt_template.json" )
prompt . input_variables # ["adjective", "content"] Erstellen Sie eine Eingabeaufforderung mit einigen Schussbeispielen:
prompt = Langchain :: Prompt :: FewShotPromptTemplate . new (
prefix : "Write antonyms for the following words." ,
suffix : "Input: {adjective} n Output:" ,
example_prompt : Langchain :: Prompt :: PromptTemplate . new (
input_variables : [ "input" , "output" ] ,
template : "Input: {input} n Output: {output}"
) ,
examples : [
{ "input" : "happy" , "output" : "sad" } ,
{ "input" : "tall" , "output" : "short" }
] ,
input_variables : [ "adjective" ]
)
prompt . format ( adjective : "good" )
# Write antonyms for the following words.
#
# Input: happy
# Output: sad
#
# Input: tall
# Output: short
#
# Input: good
# Output:Eingabeaufforderungsvorlage in JSON-Datei speichern:
prompt . save ( file_path : "spec/fixtures/prompt/few_shot_prompt_template.json" )Laden einer neuen Eingabeaufforderungsvorlage mithilfe einer JSON-Datei:
prompt = Langchain :: Prompt . load_from_path ( file_path : "spec/fixtures/prompt/few_shot_prompt_template.json" )
prompt . prefix # "Write antonyms for the following words."Laden einer neuen Eingabeaufforderungsvorlage mithilfe einer YAML-Datei:
prompt = Langchain :: Prompt . load_from_path ( file_path : "spec/fixtures/prompt/prompt_template.yaml" )
prompt . input_variables #=> ["adjective", "content"]Analysieren Sie LLM-Textantworten in eine strukturierte Ausgabe, z. B. JSON.
Sie können den StructuredOutputParser verwenden, um eine Eingabeaufforderung zu generieren, die den LLM anweist, eine JSON-Antwort bereitzustellen, die einem bestimmten JSON-Schema entspricht:
json_schema = {
type : "object" ,
properties : {
name : {
type : "string" ,
description : "Persons name"
} ,
age : {
type : "number" ,
description : "Persons age"
} ,
interests : {
type : "array" ,
items : {
type : "object" ,
properties : {
interest : {
type : "string" ,
description : "A topic of interest"
} ,
levelOfInterest : {
type : "number" ,
description : "A value between 0 and 100 of how interested the person is in this interest"
}
} ,
required : [ "interest" , "levelOfInterest" ] ,
additionalProperties : false
} ,
minItems : 1 ,
maxItems : 3 ,
description : "A list of the person's interests"
}
} ,
required : [ "name" , "age" , "interests" ] ,
additionalProperties : false
}
parser = Langchain :: OutputParsers :: StructuredOutputParser . from_json_schema ( json_schema )
prompt = Langchain :: Prompt :: PromptTemplate . new ( template : "Generate details of a fictional character. n {format_instructions} n Character description: {description}" , input_variables : [ "description" , "format_instructions" ] )
prompt_text = prompt . format ( description : "Korean chemistry student" , format_instructions : parser . get_format_instructions )
# Generate details of a fictional character.
# You must format your output as a JSON value that adheres to a given "JSON Schema" instance.
# ...Analysieren Sie dann die llm-Antwort:
llm = Langchain :: LLM :: OpenAI . new ( api_key : ENV [ "OPENAI_API_KEY" ] )
llm_response = llm . chat ( messages : [ { role : "user" , content : prompt_text } ] ) . completion
parser . parse ( llm_response )
# {
# "name" => "Kim Ji-hyun",
# "age" => 22,
# "interests" => [
# {
# "interest" => "Organic Chemistry",
# "levelOfInterest" => 85
# },
# ...
# ]
# } Wenn der Parser die LLM-Antwort nicht analysieren kann, können Sie OutputFixingParser verwenden. Es sendet eine Fehlermeldung, eine vorherige Ausgabe und den ursprünglichen Eingabeaufforderungstext an das LLM und bittet um eine „feste“ Antwort:
begin
parser . parse ( llm_response )
rescue Langchain :: OutputParsers :: OutputParserException => e
fix_parser = Langchain :: OutputParsers :: OutputFixingParser . from_llm (
llm : llm ,
parser : parser
)
fix_parser . parse ( llm_response )
end Wenn Sie die OutputParserException nicht behandeln müssen, können Sie alternativ den Code vereinfachen:
# we already have the `OutputFixingParser`:
# parser = Langchain::OutputParsers::StructuredOutputParser.from_json_schema(json_schema)
fix_parser = Langchain :: OutputParsers :: OutputFixingParser . from_llm (
llm : llm ,
parser : parser
)
fix_parser . parse ( llm_response )Ein konkretes Beispiel finden Sie hier
RAG ist eine Methodik, die LLMs dabei unterstützt, genaue und aktuelle Informationen zu generieren. Ein typischer RAG-Workflow folgt den folgenden drei Schritten:
Langchain.rb bietet zusätzlich zu den unterstützten Vectorsearch-Datenbanken eine praktische, einheitliche Schnittstelle, die es einfach macht, Ihren Index zu konfigurieren, Daten hinzuzufügen, Abfragen durchzuführen und daraus abzurufen.
| Datenbank | Open Source | Cloud-Angebot |
|---|---|---|
| Chroma | ✅ | ✅ |
| Epsilla | ✅ | ✅ |
| Hnswlib | ✅ | |
| Milvus | ✅ | ✅ Zilliz Cloud |
| Tannenzapfen | ✅ | |
| Pgvector | ✅ | ✅ |
| Qdrant | ✅ | ✅ |
| Weben | ✅ | ✅ |
| Elasticsearch | ✅ | ✅ |
Wählen Sie die Vektorsuchdatenbank aus, die Sie verwenden möchten, fügen Sie die Gem-Abhängigkeit hinzu und instanziieren Sie den Client:
gem "weaviate-ruby" , "~> 0.8.9"Wählen Sie den LLM-Anbieter aus, den Sie zum Generieren von Einbettungen verwenden, und instanziieren Sie ihn
llm = Langchain :: LLM :: OpenAI . new ( api_key : ENV [ "OPENAI_API_KEY" ] ) client = Langchain :: Vectorsearch :: Weaviate . new (
url : ENV [ "WEAVIATE_URL" ] ,
api_key : ENV [ "WEAVIATE_API_KEY" ] ,
index_name : "Documents" ,
llm : llm
)Sie können jede andere unterstützte Vektorsuchdatenbank instanziieren:
client = Langchain :: Vectorsearch :: Chroma . new ( ... ) # `gem "chroma-db", "~> 0.6.0"`
client = Langchain :: Vectorsearch :: Epsilla . new ( ... ) # `gem "epsilla-ruby", "~> 0.0.3"`
client = Langchain :: Vectorsearch :: Hnswlib . new ( ... ) # `gem "hnswlib", "~> 0.8.1"`
client = Langchain :: Vectorsearch :: Milvus . new ( ... ) # `gem "milvus", "~> 0.9.3"`
client = Langchain :: Vectorsearch :: Pinecone . new ( ... ) # `gem "pinecone", "~> 0.1.6"`
client = Langchain :: Vectorsearch :: Pgvector . new ( ... ) # `gem "pgvector", "~> 0.2"`
client = Langchain :: Vectorsearch :: Qdrant . new ( ... ) # `gem "qdrant-ruby", "~> 0.9.3"`
client = Langchain :: Vectorsearch :: Elasticsearch . new ( ... ) # `gem "elasticsearch", "~> 8.2.0"`Erstellen Sie das Standardschema:
client . create_default_schemaFügen Sie Ihrer Vektorsuchdatenbank Nur-Text-Daten hinzu:
client . add_texts (
texts : [
"Begin by preheating your oven to 375°F (190°C). Prepare four boneless, skinless chicken breasts by cutting a pocket into the side of each breast, being careful not to cut all the way through. Season the chicken with salt and pepper to taste. In a large skillet, melt 2 tablespoons of unsalted butter over medium heat. Add 1 small diced onion and 2 minced garlic cloves, and cook until softened, about 3-4 minutes. Add 8 ounces of fresh spinach and cook until wilted, about 3 minutes. Remove the skillet from heat and let the mixture cool slightly." ,
"In a bowl, combine the spinach mixture with 4 ounces of softened cream cheese, 1/4 cup of grated Parmesan cheese, 1/4 cup of shredded mozzarella cheese, and 1/4 teaspoon of red pepper flakes. Mix until well combined. Stuff each chicken breast pocket with an equal amount of the spinach mixture. Seal the pocket with a toothpick if necessary. In the same skillet, heat 1 tablespoon of olive oil over medium-high heat. Add the stuffed chicken breasts and sear on each side for 3-4 minutes, or until golden brown."
]
)Oder verwenden Sie die Dateiparser, um Daten in Ihre Datenbank zu laden, zu analysieren und zu indizieren:
my_pdf = Langchain . root . join ( "path/to/my.pdf" )
my_text = Langchain . root . join ( "path/to/my.txt" )
my_docx = Langchain . root . join ( "path/to/my.docx" )
client . add_data ( paths : [ my_pdf , my_text , my_docx ] )Unterstützte Dateiformate: docx, html, pdf, text, json, jsonl, csv, xlsx, eml, pptx.
Rufen Sie ähnliche Dokumente basierend auf der übergebenen Abfragezeichenfolge ab:
client . similarity_search (
query : ,
k : # number of results to be retrieved
)Rufen Sie ähnliche Dokumente basierend auf der über die HyDE-Technik übergebenen Abfragezeichenfolge ab:
client . similarity_search_with_hyde ( )Rufen Sie ähnliche Dokumente basierend auf der übergebenen Einbettung ab:
client . similarity_search_by_vector (
embedding : ,
k : # number of results to be retrieved
)RAG-basierte Abfrage
client . ask ( question : "..." ) Langchain::Assistant ist eine leistungsstarke und flexible Klasse, die Large Language Models (LLMs), Tools und Konversationsmanagement kombiniert, um intelligente, interaktive Assistenten zu erstellen. Es wurde entwickelt, um komplexe Konversationen zu bewältigen, Tools auszuführen und kohärente Antworten basierend auf dem Kontext der Interaktion bereitzustellen.
llm = Langchain :: LLM :: OpenAI . new ( api_key : ENV [ "OPENAI_API_KEY" ] )
assistant = Langchain :: Assistant . new (
llm : llm ,
instructions : "You're a helpful AI assistant" ,
tools : [ Langchain :: Tool :: NewsRetriever . new ( api_key : ENV [ "NEWS_API_KEY" ] ) ]
)
# Add a user message and run the assistant
assistant . add_message_and_run! ( content : "What's the latest news about AI?" )
# Supply an image to the assistant
assistant . add_message_and_run! (
content : "Show me a picture of a cat" ,
image_url : "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
)
# Access the conversation thread
messages = assistant . messages
# Run the assistant with automatic tool execution
assistant . run ( auto_tool_execution : true )
# If you want to stream the response, you can add a response handler
assistant = Langchain :: Assistant . new (
llm : llm ,
instructions : "You're a helpful AI assistant" ,
tools : [ Langchain :: Tool :: NewsRetriever . new ( api_key : ENV [ "NEWS_API_KEY" ] ) ]
) do | response_chunk |
# ...handle the response stream
# print(response_chunk.inspect)
end
assistant . add_message ( content : "Hello" )
assistant . run ( auto_tool_execution : true )Beachten Sie, dass Streaming derzeit nicht für alle LLMs unterstützt wird.
llm : Die zu verwendende LLM-Instanz (erforderlich)tools : Ein Array von Tool-Instanzen (optional)instructions : Systemanweisungen für den Assistenten (optional)tool_choice : Gibt an, wie Werkzeuge ausgewählt werden sollen. Standard: „auto“. Es kann ein spezifischer Werkzeugfunktionsname übergeben werden. Dadurch wird der Assistent gezwungen, diese Funktion immer zu verwenden.parallel_tool_calls : Ob mehrere parallele Werkzeugaufrufe durchgeführt werden sollen. Standard: wahradd_message_callback : Eine Rückruffunktion (proc, lambda), die aufgerufen wird, wenn der Konversation eine Nachricht hinzugefügt wird (optional). assistant . add_message_callback = -> ( message ) { puts "New message: #{ message } " }tool_execution_callback : Eine Rückruffunktion (proc, lambda), die direkt vor der Ausführung eines Tools aufgerufen wird (optional) assistant . tool_execution_callback = -> ( tool_call_id , tool_name , method_name , tool_arguments ) { puts "Executing tool_call_id: #{ tool_call_id } , tool_name: #{ tool_name } , method_name: #{ method_name } , tool_arguments: #{ tool_arguments } " }add_message : Fügt eine Benutzernachricht zum Nachrichtenarray hinzurun! : Verarbeitet die Konversation und generiert Antwortenadd_message_and_run! : Kombiniert das Hinzufügen einer Nachricht und das Ausführen des Assistentensubmit_tool_output : Ausgabe manuell an einen Toolaufruf sendenmessages : Gibt eine Liste der laufenden Nachrichten zurückLangchain::Tool::Calculator : Nützlich für die Auswertung mathematischer Ausdrücke. Erfordert gem "eqn" .Langchain::Tool::Database : Verbinden Sie Ihre SQL-Datenbank. Erfordert gem "sequel" .Langchain::Tool::FileSystem : Interagiert mit dem Dateisystem (Lesen und Schreiben).Langchain::Tool::RubyCodeInterpreter : Nützlich für die Auswertung von generiertem Ruby-Code. Erfordert gem "safe_ruby" (Benötigt eine bessere Lösung).Langchain::Tool::NewsRetriever : Ein Wrapper um NewsApi.org zum Abrufen von Nachrichtenartikeln.Langchain::Tool::Tavily : Ein Wrapper um Tavily AI.Langchain::Tool::Weather : Ruft die Open Weather API auf, um das aktuelle Wetter abzurufen.Langchain::Tool::Wikipedia : Ruft die Wikipedia-API auf. Der Langchain::Assistant kann problemlos mit benutzerdefinierten Tools erweitert werden, indem Klassen erstellt werden, die extend Langchain::ToolDefinition und erforderliche Methoden implementieren.
class MovieInfoTool
extend Langchain :: ToolDefinition
define_function :search_movie , description : "MovieInfoTool: Search for a movie by title" do
property :query , type : "string" , description : "The movie title to search for" , required : true
end
define_function :get_movie_details , description : "MovieInfoTool: Get detailed information about a specific movie" do
property :movie_id , type : "integer" , description : "The TMDb ID of the movie" , required : true
end
def initialize ( api_key : )
@api_key = api_key
end
def search_movie ( query : )
...
end
def get_movie_details ( movie_id : )
...
end
end movie_tool = MovieInfoTool . new ( api_key : "..." )
assistant = Langchain :: Assistant . new (
llm : llm ,
instructions : "You're a helpful AI assistant that can provide movie information" ,
tools : [ movie_tool ]
)
assistant . add_message_and_run ( content : "Can you tell me about the movie 'Inception'?" )
# Check the response in the last message in the conversation
assistant . messages . lastDer Assistent umfasst die Fehlerbehandlung für ungültige Eingaben, nicht unterstützte LLM-Typen und Fehler bei der Toolausführung. Es verwendet eine Zustandsmaschine, um den Konversationsfluss zu verwalten und verschiedene Szenarien elegant zu bewältigen.
Das Auswertungsmodul ist eine Sammlung von Tools, mit denen Sie die Leistung der Ausgabeprodukte von LLM und Ihren RAG-Pipelines (Retrieval Augmented Generation) bewerten und verfolgen können.
Ragas hilft Ihnen bei der Bewertung Ihrer RAG-Pipelines (Retrieval Augmented Generation). Die Implementierung basiert auf diesem Dokument und dem ursprünglichen Python-Repo. Ragas verfolgt die folgenden 3 Metriken und weist die Punkte 0,0–1,0 zu:
# We recommend using Langchain::LLM::OpenAI as your llm for Ragas
ragas = Langchain :: Evals :: Ragas :: Main . new ( llm : llm )
# The answer that the LLM generated
# The question (or the original prompt) that was asked
# The context that was retrieved (usually from a vectorsearch database)
ragas . score ( answer : "" , question : "" , context : "" )
# =>
# {
# ragas_score: 0.6601257446503674,
# answer_relevance_score: 0.9573145866787608,
# context_relevance_score: 0.6666666666666666,
# faithfulness_score: 0.5
# } Weitere verfügbare Beispiele: /examples
Langchain.rb verwendet den standardmäßigen Ruby Logger-Mechanismus und verwendet standardmäßig den gleichen level (derzeit Logger::DEBUG ).
So zeigen Sie alle Protokollmeldungen an:
Langchain . logger . level = Logger :: DEBUG Der Logger protokolliert standardmäßig auf STDOUT . Um das Protokollziel zu konfigurieren (d. h. in eine Datei protokollieren), gehen Sie wie folgt vor:
Langchain . logger = Logger . new ( "path/to/file" , ** Langchain :: LOGGER_OPTIONS ) Wenn Sie Probleme bei der Installation des für pragmatic_segmenter erforderlichen unicode Gems haben, führen Sie Folgendes aus:
gem install unicode -- --with-cflags= " -Wno-incompatible-function-pointer-types " git clone https://github.com/andreibondarev/langchainrb.gitcp .env.example .env und füllen Sie dann die Umgebungsvariablen in .env ausbundle exec rake um sicherzustellen, dass die Tests bestanden werden, und um standardrb auszuführenbin/console um das Gem in einer REPL-Sitzung zu laden. Fühlen Sie sich frei, Ihre eigenen Instanzen von LLMs, Tools, Agents usw. hinzuzufügen und damit zu experimentieren.gem install lefthook && lefthook install -f Treten Sie uns auf dem Langchain.rb Discord-Server bei.
Fehlerberichte und Pull-Requests sind auf GitHub unter https://github.com/andreibondarev/langchainrb willkommen.
Das Juwel ist als Open Source unter den Bedingungen der MIT-Lizenz verfügbar.
