langchainrb_rails

By default, the gem calls to_json(except: :embedding) on your model instance to create the data used for embeddings. To customize which fields are included in the vector representation, override the #as_vector method in your model.

Note: After modifying #as_vector, you must re-run Model.embed! to update the embeddings in the database.

def as_vector
  { name: name, description: description, category: category.name }.to_json
end

# Then re-generate
Product.embed!

The langchainrb_rails:assistant generator adds the necessary ActiveRecord models, migrations, controllers, views, and routes to enable Langchain::Assistant features in your Rails app. This allows you to build and chat with AI assistants immediately.

Command: rails generate langchainrb_rails:assistant --llm=openai

Available LLM options: anthropic, cohere, google_palm, google_gemini, google_vertex_ai, hugging_face, llama_cpp, mistral_ai, ollama, openai, and replicate.

To undo the installation, run: rails destroy langchainrb_rails:assistant

The langchainrb_rails:prompt generator adds a Prompt ActiveRecord model and a migration to your project. This allows you to manage and render prompt templates with dynamic variables.

Usage Example:

# Create a template with placeholders in curly braces
prompt = Prompt.create!(template: "Tell me a {adjective} joke about {subject}.")

# Render the template with specific values
prompt.render(adjective: "funny", subject: "elephants")
# => "Tell me a funny joke about elephants."

rails generate langchainrb_rails:prompt

Add the gem to your Rails application's Gemfile using Bundler:

bundle add langchainrb_rails

If you are not using Bundler, install it directly via gem:

gem install langchainrb_rails

Dependencies:

• Ruby 3.0+
• Postgres 11+ (if using Pgvector)

To add vector search capabilities to an ActiveRecord model using pgvector:

1. Run the generator specifying your model and preferred LLM: rails generate langchainrb_rails:pgvector --model=Product --llm=openai This creates the initializer, migrations, and updates your model.
2. Install dependencies and migrate the database: bundle install && rails db:migrate
3. Set your OPENAI_API_KEY environment variable.
4. Generate embeddings for existing records: Product.embed!

Use the langchainrb_rails:assistant generator to scaffold the necessary models (Assistant, Message), database migrations, controllers, views, and routes to implement an AI assistant in your Rails application.

After running the generator, you must complete these manual steps:

1. Set the required environment variable for your chosen LLM (e.g., ENV['OPENAI_API_KEY']).
2. Run rails db:migrate to create the assistants and messages tables.
3. Navigate to /assistants in your browser to begin using the assistant.

rails generate langchainrb_rails:assistant --llm=openai

Use the langchainrb_rails:pinecone Rails generator to automatically set up Pinecone integration for a specific ActiveRecord model.

This generator performs the following actions:

1. Creates a config/initializers/langchainrb_rails.rb initializer file.
2. Injects the vectorsearch class method and an after_save :upsert_to_vectorsearch callback into your specified ActiveRecord model.
3. Adds the pinecone gem to your Gemfile.

rails generate langchainrb_rails:pinecone --model=Product --llm=openai

Use the langchainrb_rails:pgvector generator to automate the setup of vector search integration for a specific Rails model. This generator performs the following actions:

1. Database Migrations: Creates migrations to enable the vector extension and add a vector column to your model's table.
2. Dependencies: Adds neighbor and ruby-openai to your Gemfile.
3. Configuration: Creates config/initializers/langchainrb_rails.rb.
4. Model Integration: Injects vectorsearch and an after_save :upsert_to_vectorsearch callback into your model file.

Required flags:

• --model: The name of the ActiveRecord model you want to enable vector search for.
• --llm: The LLM provider to use (e.g., openai). This determines the vector dimensions used for the column.

rails generate langchainrb_rails:pgvector --model=Product --llm=openai

Use the .similarity_search method to find records that most closely match a query using vector search.

Returns an ActiveRecord::Relation of matching records.

Product.similarity_search("t-shirt")

Use the .ask method on your model to perform natural language question-answering. The method generates an embedding for the question, finds similar records via cosine similarity, and passes the records (as their #as_vector representation) as context to the LLM to generate a response.

Returns a String containing the answer.

Product.ask("list the brands of shoes that are in stock")