langchainrb 0.7.5 → 0.12.0

data/lib/langchain/agent/sql_query_agent/sql_query_agent_answer_prompt.yaml

@@ -1,11 +0,0 @@
-_type: prompt
-template: |
-  Given an input question and results of a SQL query, look at the results and return the answer. Use the following format:
-  Question: {question}
-  The SQL query: {sql_query}
-  Result of the SQLQuery: {results}
-  Final answer: Final answer here
-input_variables:
-  - question
-  - sql_query
-  - results

data/lib/langchain/agent/sql_query_agent/sql_query_agent_sql_prompt.yaml

@@ -1,21 +0,0 @@
-_type: prompt
-template: |
-  Given an input question, create a syntactically correct {dialect} query to run, then return the query in valid SQL.
-  Never query for all the columns from a specific table, only ask for a the few relevant columns given the question.
-  Pay attention to use only the column names that you can see in the schema description.
-  Be careful to not query for columns that do not exist.
-  Pay attention to which column is in which table.
-  Also, qualify column names with the table name when needed.
-
-  Only use the tables listed below.
-  {schema}
-
-  Use the following format:
-
-  Question: {question}
-
-  SQLQuery:
-input_variables:
-  - dialect
-  - schema
-  - question

data/lib/langchain/agent/sql_query_agent.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module Langchain::Agent
-  class SQLQueryAgent < Base
-    attr_reader :llm, :db, :schema
-
-    #
-    # Initializes the Agent
-    #
-    # @param llm [Object] The LLM client to use
-    # @param db [Object] Database connection info
-    #
-    def initialize(llm:, db:)
-      @llm = llm
-      @db = db
-      @schema = @db.dump_schema
-    end
-
-    #
-    # Ask a question and get an answer
-    #
-    # @param question [String] Question to ask the LLM/Database
-    # @return [String] Answer to the question
-    #
-    def run(question:)
-      prompt = create_prompt_for_sql(question: question)
-
-      # Get the SQL string to execute
-      Langchain.logger.info("Passing the inital prompt to the #{llm.class} LLM", for: self.class)
-      sql_string = llm.complete(prompt: prompt).completion
-
-      # Execute the SQL string and collect the results
-      Langchain.logger.info("Passing the SQL to the Database: #{sql_string}", for: self.class)
-      results = db.execute(input: sql_string)
-
-      # Pass the results and get the LLM to synthesize the answer to the question
-      Langchain.logger.info("Passing the synthesize prompt to the #{llm.class} LLM with results: #{results}", for: self.class)
-      prompt2 = create_prompt_for_answer(question: question, sql_query: sql_string, results: results)
-      llm.complete(prompt: prompt2).completion
-    end
-
-    private
-
-    # Create the initial prompt to pass to the LLM
-    # @param question[String] Question to ask
-    # @return [String] Prompt
-    def create_prompt_for_sql(question:)
-      prompt_template_sql.format(
-        dialect: "standard SQL",
-        schema: schema,
-        question: question
-      )
-    end
-
-    # Load the PromptTemplate from the YAML file
-    # @return [PromptTemplate] PromptTemplate instance
-    def prompt_template_sql
-      Langchain::Prompt.load_from_path(
-        file_path: Langchain.root.join("langchain/agent/sql_query_agent/sql_query_agent_sql_prompt.yaml")
-      )
-    end
-
-    # Create the second prompt to pass to the LLM
-    # @param question [String] Question to ask
-    # @return [String] Prompt
-    def create_prompt_for_answer(question:, sql_query:, results:)
-      prompt_template_answer.format(
-        question: question,
-        sql_query: sql_query,
-        results: results
-      )
-    end
-
-    # Load the PromptTemplate from the YAML file
-    # @return [PromptTemplate] PromptTemplate instance
-    def prompt_template_answer
-      Langchain::Prompt.load_from_path(
-        file_path: Langchain.root.join("langchain/agent/sql_query_agent/sql_query_agent_answer_prompt.yaml")
-      )
-    end
-  end
-end

data/lib/langchain/conversation/context.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module Langchain
-  class Conversation
-    class Context < Message
-    end
-  end
-end

data/lib/langchain/conversation/memory.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module Langchain
-  class Conversation
-    class Memory
-      attr_reader :examples, :messages
-
-      # The least number of tokens we want to be under the limit by
-      TOKEN_LEEWAY = 20
-
-      def initialize(llm:, messages: [], **options)
-        @llm = llm
-        @context = nil
-        @summary = nil
-        @examples = []
-        @messages = messages
-        @strategy = options.delete(:strategy) || :truncate
-        @options = options
-      end
-
-      def set_context(message)
-        @context = message
-      end
-
-      def add_examples(examples)
-        @examples.concat examples
-      end
-
-      def append_message(message)
-        @messages.append(message)
-      end
-
-      def reduce_messages(exception)
-        case @strategy
-        when :truncate
-          truncate_messages(exception)
-        when :summarize
-          summarize_messages
-        else
-          raise "Unknown strategy: #{@options[:strategy]}"
-        end
-      end
-
-      def context
-        return if @context.nil? && @summary.nil?
-
-        Context.new([@context, @summary].compact.join("\n"))
-      end
-
-      private
-
-      def truncate_messages(exception)
-        raise exception if @messages.size == 1
-
-        token_overflow = exception.token_overflow
-
-        @messages = @messages.drop_while do |message|
-          proceed = token_overflow > -TOKEN_LEEWAY
-          token_overflow -= token_length(message.to_json, model_name, llm: @llm)
-
-          proceed
-        end
-      end
-
-      def summarize_messages
-        history = [@summary, @messages.to_json].compact.join("\n")
-        partitions = [history[0, history.size / 2], history[history.size / 2, history.size]]
-
-        @summary = partitions.map { |messages| @llm.summarize(text: messages.to_json) }.join("\n")
-
-        @messages = [@messages.last]
-      end
-
-      def partition_messages
-      end
-
-      def model_name
-        @llm.class::DEFAULTS[:chat_completion_model_name]
-      end
-
-      def token_length(content, model_name, options)
-        @llm.class::LENGTH_VALIDATOR.token_length(content, model_name, options)
-      end
-    end
-  end
-end

data/lib/langchain/conversation/message.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Langchain
-  class Conversation
-    class Message
-      attr_reader :content
-
-      ROLE_MAPPING = {
-        context: "system",
-        prompt: "user",
-        response: "assistant"
-      }
-
-      def initialize(content)
-        @content = content
-      end
-
-      def role
-        ROLE_MAPPING[type]
-      end
-
-      def to_s
-        content
-      end
-
-      def to_h
-        {
-          role: role,
-          content: content
-        }
-      end
-
-      def ==(other)
-        to_json == other.to_json
-      end
-
-      def to_json(options = {})
-        to_h.to_json
-      end
-
-      private
-
-      def type
-        self.class.to_s.split("::").last.downcase.to_sym
-      end
-    end
-  end
-end

data/lib/langchain/conversation/prompt.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module Langchain
-  class Conversation
-    class Prompt < Message
-    end
-  end
-end

data/lib/langchain/conversation/response.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module Langchain
-  class Conversation
-    class Response < Message
-    end
-  end
-end

data/lib/langchain/conversation.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module Langchain
-  #
-  # A high-level API for running a conversation with an LLM.
-  # Currently supports: OpenAI and Google PaLM LLMs.
-  #
-  # Usage:
-  #     llm = Langchain::LLM::OpenAI.new(api_key: "YOUR_API_KEY")
-  #     chat = Langchain::Conversation.new(llm: llm)
-  #     chat.set_context("You are a chatbot from the future")
-  #     chat.message("Tell me about future technologies")
-  #
-  # To stream the chat response:
-  #     chat = Langchain::Conversation.new(llm: llm) do |chunk|
-  #       print(chunk)
-  #     end
-  #
-  class Conversation
-    attr_reader :options
-
-    # Intialize Conversation with a LLM
-    #
-    # @param llm [Object] The LLM to use for the conversation
-    # @param options [Hash] Options to pass to the LLM, like temperature, top_k, etc.
-    # @return [Langchain::Conversation] The Langchain::Conversation instance
-    def initialize(llm:, **options, &block)
-      @llm = llm
-      @context = nil
-      @examples = []
-      @memory = ::Langchain::Conversation::Memory.new(
-        llm: llm,
-        messages: options.delete(:messages) || [],
-        strategy: options.delete(:memory_strategy)
-      )
-      @options = options
-      @block = block
-    end
-
-    def set_functions(functions)
-      @llm.functions = functions
-    end
-
-    # Set the context of the conversation. Usually used to set the model's persona.
-    # @param message [String] The context of the conversation
-    def set_context(message)
-      @memory.set_context ::Langchain::Conversation::Context.new(message)
-    end
-
-    # Add examples to the conversation. Used to give the model a sense of the conversation.
-    # @param examples [Array<Prompt|Response>] The examples to add to the conversation
-    def add_examples(examples)
-      @memory.add_examples examples
-    end
-
-    # Message the model with a prompt and return the response.
-    # @param message [String] The prompt to message the model with
-    # @return [Response] The response from the model
-    def message(message)
-      @memory.append_message ::Langchain::Conversation::Prompt.new(message)
-      ai_message = ::Langchain::Conversation::Response.new(llm_response.chat_completion)
-      @memory.append_message(ai_message)
-      ai_message
-    end
-
-    # Messages from conversation memory
-    # @return [Array<Prompt|Response>] The messages from the conversation memory
-    def messages
-      @memory.messages
-    end
-
-    # Context from conversation memory
-    # @return [Context] Context from conversation memory
-    def context
-      @memory.context
-    end
-
-    # Examples from conversation memory
-    # @return [Array<Prompt|Response>] Examples from the conversation memory
-    def examples
-      @memory.examples
-    end
-
-    private
-
-    def llm_response
-      @llm.chat(messages: @memory.messages.map(&:to_h), context: @memory.context&.to_s, examples: @memory.examples.map(&:to_h), **@options, &@block)
-    rescue Langchain::Utils::TokenLength::TokenLimitExceeded => exception
-      @memory.reduce_messages(exception)
-      retry
-    end
-  end
-end

data/lib/langchain/tool/database.rb

@@ -1,90 +0,0 @@
-module Langchain::Tool
-  class Database < Base
-    #
-    # Connects to a database, executes SQL queries, and outputs DB schema for Agents to use
-    #
-    # Gem requirements: gem "sequel", "~> 5.68.0"
-    #
-
-    NAME = "database"
-
-    description <<~DESC
-      Useful for getting the result of a database query.
-
-      The input to this tool should be valid SQL.
-    DESC
-
-    attr_reader :db, :requested_tables, :excluded_tables
-
-    #
-    # Establish a database connection
-    #
-    # @param connection_string [String] Database connection info, e.g. 'postgres://user:password@localhost:5432/db_name'
-    # @param tables [Array<Symbol>] The tables to use. Will use all if empty.
-    # @param except_tables [Array<Symbol>] The tables to exclude. Will exclude none if empty.
-
-    # @return [Database] Database object
-    #
-    def initialize(connection_string:, tables: [], exclude_tables: [])
-      depends_on "sequel"
-
-      raise StandardError, "connection_string parameter cannot be blank" if connection_string.empty?
-
-      @db = Sequel.connect(connection_string)
-      @requested_tables = tables
-      @excluded_tables = exclude_tables
-    end
-
-    #
-    # Returns the database schema
-    #
-    # @return [String] schema
-    #
-    def dump_schema
-      Langchain.logger.info("Dumping schema tables and keys", for: self.class)
-      schema = ""
-      db.tables.each do |table|
-        next if excluded_tables.include?(table)
-        next unless requested_tables.empty? || requested_tables.include?(table)
-
-        primary_key_columns = []
-        primary_key_column_count = db.schema(table).count { |column| column[1][:primary_key] == true }
-
-        schema << "CREATE TABLE #{table}(\n"
-        db.schema(table).each do |column|
-          schema << "#{column[0]} #{column[1][:type]}"
-          if column[1][:primary_key] == true
-            schema << " PRIMARY KEY" if primary_key_column_count == 1
-          else
-            primary_key_columns << column[0]
-          end
-          schema << ",\n" unless column == db.schema(table).last && primary_key_column_count == 1
-        end
-        if primary_key_column_count > 1
-          schema << "PRIMARY KEY (#{primary_key_columns.join(",")})"
-        end
-        db.foreign_key_list(table).each do |fk|
-          schema << ",\n" if fk == db.foreign_key_list(table).first
-          schema << "FOREIGN KEY (#{fk[:columns][0]}) REFERENCES #{fk[:table]}(#{fk[:key][0]})"
-          schema << ",\n" unless fk == db.foreign_key_list(table).last
-        end
-        schema << ");\n"
-      end
-      schema
-    end
-
-    #
-    # Evaluates a sql expression
-    #
-    # @param input [String] sql expression
-    # @return [Array] results
-    #
-    def execute(input:)
-      Langchain.logger.info("Executing \"#{input}\"", for: self.class)
-
-      db[input].to_a
-    rescue Sequel::DatabaseError => e
-      Langchain.logger.error(e.message, for: self.class)
-    end
-  end
-end