DEV Community: Andres Urdaneta

How to Fix Random OpenAI 500 Errors in Rails Background Jobs Using retry_on

Andres Urdaneta — Sun, 14 Sep 2025 13:56:29 +0000

Introduction

When you're building applications that rely on third-party APIs, one of the certainties is that those APIs will, at some point, fail.

Network issues, transient server errors, or rate limiting can all lead to failed requests. A robust application needs to anticipate these failures and handle them gracefully.

In this tutorial, we'll walk through a real-world scenario I recently encountered in one of my Rails projects.

My app uses the ruby-openai gem to interact with the OpenAI API, and I noticed that the background job responsible for generating the LLM responses was intermitently failing with a Faraday::ServerError.

We'll look at how I diagnosed the problem and used Rails' built-in features to make my background jobs more resilient.

The Problem: A Failing Background Job

The issue started with jobs landing in my "failed" queue. The error was always the same: Faraday::ServerError: the server responded with status 500.

Here's a snippet of the stack trace:

/usr/local/bundle/ruby/3.3.0/gems/faraday-2.13.1/lib/faraday/response/raise_error.rb:38:in `on_complete'
...
/rails/app/services/llm/assistant_response_service.rb:22:in `generate_response'
/rails/app/jobs/llm/assistant_response_job.rb:13:in `perform'
...

Here's the generate_response method responsible for making the API call to OpenAI

# `app/services/assistant_response_service.rb`

class Llm::AssistantResponseService < Llm::BaseOpenAiService

    # ...

    def generate_response
        parameters = {
            model: DEFAULT_MODEL,
            input: @input_messages,
            tools: @tool_registry&.registered_tools || [],
            previous_response_id: chat.previous_response_id,
            text: {
                verbosity: "low"
            }
        }

        response = client.responses.create(parameters: parameters)
        handle_response(response)
    end

    # ...

end

And here's the background job that was calling it

# `app/jobs/llm/assistant_response_job.rb`
class Llm::AssistantResponseJob < ApplicationJob
    queue_as :default

    def perform(message_id)
        message = Message.includes(chat: :chatbot).find(message_id)
        chat = message.chat
        chatbot = chat.chatbot

        Llm::AssistantResponseService.new(
            input_message: message.content,
            chat: chat,
            chatbot: chatbot,
        ).generate_response
    end
end

This wasn't an error in my code, but an issue on OpenAI's end. However, my app wasn't handling it well. The job would try once, fail, and give up.

The problem was that there wasn't any handling for Faraday::ServerError. The job simply fails and is moved to the dead-letter queue, requiring manual intervention to retry.

The Solution: Automatic Retries with Active Job

The best way to handle transient errors like a 500 status is to simply try again after a short delay. Fortunately, Rails makes this trivial with the retry_on feature.

Step 1: Add Retries to the Job

The first and most important change is to tell our job to retry when it encounters a Faraday::ServerError.

I modified app/jobs/llm/assistant_response_job.rb like this:

# app/jobs/llm/assistant_response_job.rb

class Llm::AssistantResponseJob < ApplicationJob
    queue_as :default

    # **********************
    # ADD THIS NEXT LINE ⬇️
    # **********************
    retry_on Faraday::ServerError, wait: :polynomially_longer, attempts: 3

    def perform(message_id)
        message = Message.includes(chat: :chatbot).find(message_id)
        chat = message.chat
        chatbot = chat.chatbot

        Llm::AssistantResponseService.new(
            input_message: message.content,
            chat: chat,
            chatbot: chatbot,
        ).generate_response
    end
end

With this single line, the job will now:

Catch any Faraday::ServerError that occurs during its execution.
Automatically re-enqueue itself to be run again later.
Wait for a polynomially increasing amount of time between retries (:polynomially_longer)

:polynomially_longer is a built-in backoff strategy for retries in Rails. It makes the wait time between retries increasingly grow using a formula based on the number of attempts so far: wait_time = (executions ** 4) + (random_jitter) + 2. E.g:

- **First retry:** about **3 seconds**
- **Second retry:** about **18 seconds**
- **Third retry:** about **83 seconds**
- **Fourth retry:** much longer, and so on.

The idea is to give the system more and more time to recover before trying again, instead of hammering the failing api at a fixed interval.

Attempt this up to 3 times before finally giving up and moving to the failed jobs queue.

This immediately makes our job much more robust.

Step 2: Improve Error Logging

While retrying is great, we still want to know when these errors are happening. To fix this, we need to rescue the error in the service, log it, and then re-raise it so that the job's retry_on handler can catch it.

Here's the updated generate_response method in app/services/llm/assistant_response_service.rb:

# app/services/llm/assistant_response_service.rb

class Llm::AssistantResponseService
# ...
    def generate_response
    # ...
    response = client.responses.create(parameters: parameters)
    handle_response(response)
    rescue Faraday::ServerError => e # <-- Add this rescue block
        log_error(e, parameters) # <-- Log the error
        raise e # <-- Re-raise the exception
    end

    private

        def log_error(error, parameters = {})
            # Log the error to a monitoring and error tracking service, e.g: Sentry
        end
end

The key here is raise e. If we just rescued the exception without re-raising it, the job would never know that an error occurred, and it wouldn't retry. By rescuing, logging, and re-raising, we get the best of both worlds: visibility into the errors and automatic retries.

Conclusion

By combining Active Job's retry_on with specific error handling and logging, we just built a resilient background job.

Implementing this is incredibly effective for dealing with unreliable network requests to third-party services, guarantees that your users will have a smoother experience and you'll spend less time manually retrying failed jobs.

Next time you're working with an external API, remember to ask yourself: "What happens if this fails?" and build in a resilient error-handling strategy from the start.

If you enjoyed this tutorial, here's where to find more of my work:

Untaught Blog
Read Article Here
Follow me on X

How to Build AI-Generated Loading Messages in Rails 8 with Hotwire & Stimulus

Andres Urdaneta — Wed, 27 Aug 2025 20:04:44 +0000

Have you noticed how Claude Code shows funny loading messages while it’s working? Things like “Wizarding” or “Pontificating.”

I think they’re fun. They give you a small taste of what user experiences with AI could look like in the future.
In this tutorial, we’ll build our own version of that in Ruby on Rails.

The app will generate dynamic loading messages with a little help from AI. Here’s a quick preview:

Here’s the flow:

When a user submits a form, we’ll start two background jobs. One will simulate a slow process, and the other will create a list of AI-powered loading phrases.
While those jobs are running, we’ll show a few hard-coded loading messages.
As soon as the AI phrases are ready, we’ll stream them to the browser, swap them in, and shuffle them with JavaScript. Finally, once the slow process is done, we’ll show a “success” message.

Before we start: What are we using?

For this tutorial, we’ll be using:

Ruby on Rails 8 with Solid Queue and Solid Cable — to run background jobs and stream updates to the browser in real time. > I won’t cover how to set up Solid Queue and Solid Cable here. I’ll link a separate guide soon on setting up the full Rails 8 Solid Trifecta (Solid Cache, Solid Queue, Solid Cable).
StimulusJS — to shuffle the loading phrases every 2 seconds.
ruby_llm and ruby_llm-schema gems — to easily interact with any AI model provider (OpenAI, Anthropic, Gemini, etc.) and enforce structured outputs.

That’s it! Let’s dive in.

### Step 1. Create new Rails app

rails new phrase_cycler \
--database=sqlite3 \ # simple, zero-config DB for a demo
--css=tailwind \ # easy styling
--javascript=importmap\ # no bundler needed
--stimulus \ # to sprinkle some javascript in our views
--skip-test # keeps the demo lean, we won't get into testing

cd phrase_cycler

Awesome, we have created our Rails "Phrase Cycler" application.

Step 2. Set up a resource controller

We'll make a simple (and dummy) ResourcesController to trigger our background jobs when the user submits a message.

But a "resource" could be anything, for example, instead of ResourcesController you might want a PostsController, a ChatsController or whatever your resource is.

Let's go ahead and run the following generator in your terminal:

rails g controller resources index create

This will:

Create ResourcesController#index and ResourcesController#create actions
Add the matching view files
Add routes to routes.rb

But we don’t actually want the default routes it gives us. In routes.rb, Rails will add these:

get "resources/index"
get "resources/create"

Let’s remove them and replace with this:

resources :resources, only: [ :index, :create ]
root "resources#index"

What this does:

Creates a POST /resources route (for form submits)
Creates a GET /resources route (for rendering the page)
Sets the root path / to load ResourcesController#index

To double check, run:

rails routes -g resources

And you should see:

resources GET  /resources(.:format) resources#index
          POST /resources(.:format) resources#create
     root GET  /                    resources#index

Great. Our routes are set.

3. Build the user interface

We’ll use TailwindCSS v4 and DaisyUI so things look clean and consistent without much effort.

To add DaisyUI to our Rails app, run this in the root directory:

curl -sLo app/assets/tailwind/daisyui.js https://github.com/saadeghi/daisyui/releases/latest/download/daisyui.js

This pulls the latest DaisyUI into a single JS file.

Now open application.css and add this:

@import "tailwindcss";
@source "../../../public/*.html";
@source "../../../app/helpers/**/*.rb";
@source "../../../app/javascript/**/*.js";
@source "../../../app/views/**/*";

@plugin "./daisyui.js" {
    themes: lofi --default
}

That’s it. Tailwind and DaisyUI are ready to go.

3.1 Create the UI
Our UI is very simple: a form with one text box and a button. When the user submits, we’ll show the loading phrases like “Loading…”, “Thinking…”, or “Crunching…”.

Later we’ll wire it up with Hotwire, JavaScript, and a few partials. For now, add this to app/views/resources/index.html.erb:

<div class="w-full">
    <div class="flex flex-col items-center justify-center gap-4">
        <%# Loader %>
        <div id="resource-status-container"></div>
        <%# Form %>
        <div class="w-full flex justify-center">
            <%= form_with url: resources_path, method: :post, class: "flex flex-col gap-4 min-w-96", data: { turbo: true } do |form| %>
                <%= form.text_field :message, placeholder: "Send a message", class: "input w-full" %>
                <%= form.submit "Submit", class: "btn btn-primary w-full" %>
            <% end %>
        </div>
    </div>
</div>

At this point, if you run the server and open http://localhost:3000, you should see a clean form on the homepage ready to send messages.

4. Hard-coded loading phrases

Before we bring AI into the mix, let’s zoom out and ask: what are we really trying to do here?

A user submits a message and while waiting for a slow process to finish, we shuffle through fun loading phrases.

Do we need AI for that? Nope. We can just hard code a few phrases and cycle through them with Stimulus. Quick win.

So let’s start simple: submit the form, show phrases, shuffle them on screen.

4.1 Update the controller
In ResourcesController#create, drop this in:

def create
    # TODO: Enqueue slow process background job here

    respond_to do |format|
        format.turbo_stream do
            render turbo_stream: turbo_stream.update(
                "resource-status-container",
                partial: "resources/loader",
                locals: { phrases: ["Concocting", "Prepping", "Pouring"] }
            )
        end
        format.html { redirect_to resources_path, notice: "Resource created successfully" }
    end
end

Here’s what’s happening:

User submits the form.
We immediately respond with a Turbo Stream.
That Turbo Stream replaces the empty resource-status-container with our new partial _loader.html.erb, passing along a list of static phrases.

4.2 Build the loader partial
Create app/views/resources/_loader.html.erb:

<div class="flex items-center gap-2">
    <span class="loading loading-ring loading-xl"></span>
    <span class="max-w-14 min-w-14 w-14 text-sm text-start">
        <%= phrases.first %>...
    </span>
</div>

Now when you submit the form, you’ll see a spinner and one phrase (like Concocting...).

4.3 Cycle phrases with Stimulus
Right now it only shows the first phrase. Let’s rotate them every 2 seconds with Stimulus.

Generate a Stimulus controller:

rails g stimulus PhraseCycler

That gives you app/javascript/controllers/phrase_cycler_controller.js. Add this:

import { Controller } from "@hotwired/stimulus"

// Connects to data-controller="phrase-cycler"
export default class extends Controller {
    static targets = ["label"]
    static values = {
        phrases: Array
    } 

    connect() {
        this.index = 0;
        this.words = this.phrasesValue.map(phrase => `${phrase}...`);

        if (this.labelTarget.textContent.trim() === "") {
            this.labelTarget.textContent = this.words[this.index];
        }

        this.timer = setInterval(() => {
            this.cycle();
        }, 2000);
    }

    disconnect() {
        setTimeout(() => {
            clearInterval(this.timer);
        }, this.timer);
    }

    cycle() {
        this.index = (this.index + 1) % this.words.length;
        this.labelTarget.textContent = this.words[this.index];
    }

}

4.4 Hook up the Stimulus controller
Update the loader partial to use the Stimulus controller:

<div class="flex items-center gap-2" data-controller="phrase-cycler" data-phrase-cycler-phrases-value="<%= phrases.to_json %>">
    <span class="loading loading-ring loading-xl"></span>
    <span class="max-w-14 min-w-14 w-14 text-sm text-start" data-phrase-cycler-target="label">
        <%= phrases.first %>...
    </span>
</div>

Now, when the loader partial is injected, the Stimulus controller connects and cycles through the phrases automatically every 2 seconds.

Neat, right? We now have a cycling loader that feels alive. Way better than just Loading....

Next up we’ll simulate a slow background job to dismiss the loader, then bring AI into the mix for truly dynamic phrases.

Step 5. Simulating a long-process background job

When ResourcesController#create runs, we also want to enqueue a slow process. Once it’s done, it should swap the loader with either a success or failure message.

rails g job SlowProcess

And here’s the job code:

class SlowProcessJob < ApplicationJob
    queue_as :default

    def perform
        sleep 20
        stream_to_target("success")
    rescue StandardError => _
        stream_to_target("failure")
    end

    private

    def stream_to_target(status)
        Turbo::StreamsChannel.broadcast_update_to(
            "resource_channel",
            target: "resource-status-container",
            partial: "resources/#{status}"
        )
    end

end

What’s happening:

We fake a slow process with sleep 20.
When it’s done, we stream either success or failure to the resource_channel.
That update replaces the loader in resource-status-container.

5.1 Create the success and failure partials

<%# app/views/resources/_success.html.erb %>
<div>
    <span class="text-sm text-green-500">Success!</span>
</div>

<%# app/views/resources/_failure.html.erb %>
<div>
    <span class="text-red-500">Failure!</span>
</div>

5.2 Subscribe the view to a Turbo Stream
At the top of app/views/resources/index.html.erb, add:

<%= turbo_stream_from "resource_channel" %>

5.3 Update the controller action
Don't forget to enqueue the SlowProcessJob in the ResourcesController#create here's the updated controller action

def create
    SlowProcessJob.perform_later

    respond_to do |format|
        format.turbo_stream do
            render turbo_stream: turbo_stream.append("resource-status-container", partial: "resources/loader", locals: { phrases: [ "Concocting", "Prepping", "Pouring" ] })
        end

        format.html { redirect_to resources_path }
    end
end

Now when you submit the form:

The loader kicks in with cycling phrases.
SlowProcessJob is enqueued and runs in the background.
After ~20 seconds, the job finishes.
The loader is replaced with Success! (or Failure! if something goes wrong).

Awesome. At this point, you’ve got a fully working flow: The user submits the form. An animated loader is displayed. The slow jobs gets enqueued and once finished it streams the success partial.

We can call it a day. But we didn’t come all this way just for hard-coded phrases. Let's go ahead and implement those AI generated loading phrases...

6. AI-Generated loading phrases with RubyLLM

We’ll create a new background job that asks an LLM (like OpenAI) for random loading phrases.

6.1 Create the job

rails g job GenerateLoadingPhrases

This gives us app/jobs/generate_loading_phrases_job.rb

6.2 Configure RubyLLM
First, install the gem:

bundle add ruby_llm

Then add an initializer config/initializers/ruby_llm.rb:

require "ruby_llm"

RubyLLM.configure do |config|
    # Add keys ONLY for the providers you intend to use.
    config.openai_api_key = ENV.fetch("OPENAI_API_KEY", nil)
    config.default_model = "gpt-4o-mini"
    # config.anthropic_api_key = ENV.fetch('ANTHROPIC_API_KEY', nil)
end

Don’t forget to add your API key to your .env, e.g.:

# .env
OPENAI_API_KEY=123abc

RubyLLM gives us a clean interface to interact with OpenAI, Anthropic, Gemini, DeepSeek, and more. It's a pretty easy and powerful gem to use.

6.3 Add structured output with ruby_llm-schema
We need the AI to return a list of phrases (an array of strings). By default, RubyLLM doesn’t support structured responses. That’s where ruby_llm-schema comes in.

Let's install it.

bundle add ruby_llm-schema

Then, create app/schemas/phrase_schema.rb:

class PhraseSchema < RubyLLM::Schema
    array :phrases, of: :string
end

6.4 Implement the job
Inside app/jobs/generate_loading_phrases_job.rb add this code:

def perform(message)
    phrases = fetch_phrases(message)
    stream_to_target(phrases)
rescue StandardError => _
    # If the job fails, do nothing
    nil
end

private

def fetch_phrases(message)
    chat = RubyLLM.chat
    chat.with_instructions(prompt)
    response = chat.with_schema(PhraseSchema).ask(message)
    response.content["phrases"]
end

def stream_to_target(phrases)
    Turbo::StreamsChannel.broadcast_update_to(
        "resource_channel",
        target: "resource-status-container",
        partial: "resources/loader",
        locals: { phrases: phrases }
    )
end

def prompt
    <<~PROMPT
    Analyze this message and come up with a list of positive, cheerful and delightful verbs in gerund form that's related to the message. Only include words with no other text or punctuation. These words should have the first letter capitalized. Add some quaint and surprise to entertain the user. Ensure each word is highly relevant to the user's message. Obscure words are preferred but be careful to avoid words that might look alarming or concerning to the software engineer seeing it as a status notification, such as Connecting, Disconnecting, Retrying, Lagging, Freezing, etc. NEVER use a destructive word, such as Terminating, Killing, Deleting, Destroying, Stopping, Exiting, or similar. NEVER use a word that may be derogatory, offensive, or inappropriate in a non-coding context, such as Penetrating.
    PROMPT
end

6.5 Update the controller
And finally, enqueue the new job inside ResourcesController#create:

def create
    GenerateLoadingPhrasesJob.set(priority: -10).perform_later(params[:message])
    SlowProcessJob.perform_later

    respond_to do |format|
        format.turbo_stream do
            render turbo_stream: turbo_stream.append("resource-status-container", partial: "resources/loader", locals: { phrases: [ "Concocting", "Prepping", "Pouring" ] })
        end

        format.html { redirect_to resources_path }
    end
end

Let me explain what's going on here.

6.6 How it works?

GenerateLoadingPhrasesJob runs with a higher priority so it finishes before the slow job.
It sends a structured request to the LLM (with our schema + prompt).
The LLM responds with a list of phrases.
The job streams those new phrases to the resource_channel, updating the loader.
The Stimulus controller takes over and cycles through them.
Once the slow job finishes, it streams Success (or Failure) and replaces the loader.

At this point, you’ve got AI-powered dynamic loading phrases!

The user submits a message, sees playful phrases that actually relate to their input, and then a final success message.

For example:

"Exploring", "Wandering", "Dancing", "Glimmering", "Sparkling", "Fluttering", "Radiating", "Savoring", "Whimsicalizing", "Delighting"

Conclusion

That’s a wrap! In this tutorial, we have learned how to create dynamic loading messages using the AI.

This is a simple but powerful technique to make your apps feel alive and fun. Try tweaking the prompt to see what unique and corny phrases the AI comes up with. That's where the magic happens!

If you enjoyed this tutorial, here's where to find more of my work:

Untaught Blog
Read Article Here
Follow me on X

How I Run My SaaS for $45/month Without Supabase, Vercel, or Firebase. Just Rails.

Andres Urdaneta — Tue, 03 Jun 2025 18:50:04 +0000

Everyone’s talking about Supabase, Vercel, Firebase, Replit, and similar services as the go-to stack to launch SaaS apps fast.

I tried them.

They’re sleek and easy to use. But once I started estimating real-world costs for my project, I realized they add up fast, and that’s a problem when you're launching without real users yet.

So I built my SaaS, Odichat, with a different approach — one that costs me $45/month and gives me full control, solid performance, and zero vendor lock-in.

Let me break it down.

The Stack

Here’s what I’m running:

A production-ready Rails 8 app
A staging environment for safe deployments
File storage for user uploads
Transactional emails
Background job processing
Websockets
Caching

And all of this for $45/month.

The Costs

Here’s the exact monthly breakdown:

Hetzner dedicated vCPU (production): $13.49
Hetzner shared vCPU (remote builder): $4.99 (used for asset precompilation and deploys)
Hetzner shared vCPU (staging): $4.99
DigitalOcean Spaces (file storage): $5.33
Zoho Mail (support email inbox): $1
Postmark (transactional emails): $15

Total: $45.80 USD/month

SQLite3 is my database

I’m using SQLite3 as the database.

Yep, SQLite in production.

It’s free, and for my current load it works perfectly. I haven’t had a single issue that justifies migrating to PostgreSQL (yet).

No Redis. I'm fine.

Rails 8 ships with the “Solid” suite:

Solid Queue (background jobs)
Solid Cache
Solid Cable (Websockets)

It’s a full-featured solution without extra setup or Redis requirements. And it performs great.

Why not serverless?

Because I want:

Predictable, low costs
Zero surprises from usage-based pricing
Infra I understand and can control
The ability to grow into higher traffic without switching stacks

I’m not anti-serverless. But at this stage, this is the simplest and most sustainable setup I’ve found.

Final thoughts!

It’s not “trendy”.

It’s not “modern”.

But it works AMAZINGLY well, it’s cheap, and it lets me focus on building, not budgeting.

If you’re building a SaaS and want full control without overpaying early on, I highly recommend exploring this kind of setup — especially if you’re using Rails.

Classify & Label Customer Service Chats with Python, OpenAI and Langchain

Andres Urdaneta — Mon, 24 Feb 2025 18:14:21 +0000

LLMs with Structured Outputs make classifying and labeling text incredibly easy. Today, we’ll write a script to do exactly that—classifying a customer service chat.

We’ll extract and label key details from the chat, including the user’s name, sentiment, language, and the topic of their conversation with a customer service representative.

Before jumping into the code, let’s review the tools and requirements:

Python installed locally
OpenAI API Key
A text file containing the conversation between the representative and the client

Create The Project Directory

Now, let’s go ahead and create our project directory and cd into it.

mkdir text_classification && cd text_classification

Let’s make sure we’ve got our tools and project prepped. So let’s create the entry point file of the project within the root directory

touch main.py

Now, create a virtual environment to keep our dependencies contained so they don’t mess with system-wide Python packages, and then activate it.

python -m venv .venv
source .venv/bin/activate

Installing Dependencies

With our virtual environment in place, let’s go ahead and install our dependencies. I’m using pipso I’ll run the following command in my project terminal

pydantic, a widely used Python validation library. It will let us declare the schema of the structured output response we expect from the LLM.
langchain , is a framework and package that makes it easier to work with LLMs in Python.
langchain-openai, a Langchain package that provides seamless integration with OpenAI’s models.

I’m using pip to install these dependencies so I’ll run the following command in my project terminal:

pip install pydantic langchain langchain-openai

ENVs & Chat Text File

Great! Now that we've installed our dependencies, let's create a .env file to store our OpenAI API key.

OPENAI_API_KEY=sk….

And before finally getting our hands dirty, let’s not forget about the chat data!

I exported a conversation between a customer service representative and a customer from WhatsApp into a text file.

You can use my sample chat file or bring your own.

I’ll drop the text file in the project’s root directory, so we can later pass the contents of that file to the LLM.

Getting Started

Now that everything’s set up, it’s time to crack open main.py and get coding.

First things first, let’s make sure the OpenAI API key is actually set—otherwise we won’t get LLM responses.

import os

if not os.getenv("OPENAI_API_KEY"):
   raise ValueError("OPENAI_API_KEY is not set")

Then, let’s run in our terminal the following command:

python main.py

If no errors pop up, you're good to go.

But in case you get an error, try closing and re-opening your terminal. A new terminal will load your variables in the .env file.

Next, let’s import the other modules we’re going to need for this script

from pydantic import BaseModel, Field
from langchain.chat_models import init_chat_model

The Classification Schema

Now let’s see the meat and potatoes of this classification and labeling script.

We’ll use Pydantic to define a Classification class that serves as the schema we’ll pass later on to the LLM so it knows what information to extract and label from the chat.

class Classification(BaseModel):
   name: str = Field(description=“The name of the user”)
   sentiment: str = Field(
       description="The sentiment of the user",
       enum=["positive", "negative", "neutral"],
     )
   language: str = Field(
       description="The language of the user",
       enum=["spanish", "english"],
   )
   issue: str = Field(
       description="The issue of the user",
       enum=["technical", "billing", "account", "other"],
   )

As you can see, the schema’s name field only has a description attribute that specifies to get the client’s name. However, the other fields also include an enum.

The reason for adding enum to some fields is to make sure the model classifies only within predefined categories, reducing ambiguity and making the data easier to store and analyze.

Structured Outputs

Now, let’s create a chat model. We’ll use the with_structured_output to pass our Classification schema.

Under the hood, Langchain’s with_structured_output method makes sure the LLM has Structured Output enabled.

llm = init_chat_model("gpt-4o-mini", model_provider="openai").with_structured_output(Classification)

Next, we’ll save the chat contents from chat.txt and create a full prompt for the LLM.

with open("chat.txt", "r") as f:
   chat_text = f.read()

prompt = """Extract the desired information from the following chat.
Only extract the properties mentioned in the 'Classification' function.
Conversation:\n"""

Finally, let’s invoke the LLM with our prompt and chat text contents and print the results

response = llm.invoke(prompt + chat_text)
print(response)

In our terminal, let’s run the script

> python main.py
name='Andres Urdaneta' sentiment='neutral' language='spanish' issue='other'

Wrap-up & Next Steps

And there you have it—a fully functional script that classifies and labels customer service chats using Python, OpenAI API, and Langchain!

With just a few lines of code, we structured an unorganized conversation into clear, actionable data.

This setup can serve as the foundation for automating customer insights, building smarter chatbots, or even integrating AI-driven analytics into your workflow.

Try tweaking the classification schema, adding more categories, or even chaining multiple prompts together, and have fun!

If you have any questions or would like to connect, hit me up on X or LinkedIn

Read this article on my website

How to change App ID/Package Name for Android app built with React Native

Andres Urdaneta — Fri, 10 Jun 2022 00:25:24 +0000

When uploading a bundled version of your Android app to Google Play Console, you might need to change your Package Name / Application ID to satisfy Google Play Console rules.

If you are getting an error like the following (or something similar)

You need to use a different package name because "com.***.***.***" already exists in Google Play

Then try out the following steps.

Change Package Name / Application ID in Android app built with React Native.

In VSCode go to the Search

Enter your current Package Name / Application ID in the search text input.

NOTE: If you don't know what's your current Package Name / Application ID, you can find it within the android/app/build.gradle file, in the applicationId field. In my case, the current Package Name / Application ID is com.papitas.

Enter the path to your android directory in the files to include text input.

In my case my android directory lives under projectrootdir/apps/mobile/android yours could be different,

This will display all the instances of the string com.papitas.

Use the "Replace" text input to replace your current Package Name / Application ID for the new one.

That's it!

Stop using relative paths in your React Native imports. Use Aliases instead.

Andres Urdaneta — Sun, 06 Jun 2021 22:16:43 +0000

Use Aliases in your imports with Babel

Instead of doing this in your imports i.e:

import Component from '../../../components/shared/Header';

You could do something like this from anywhere in your project i.e:

import Component from 'components/shared/Header';

Or you could even go as deep as you want i.e:

import Component from '@/shared/Header';

You get the point... no more relative paths ('../../../../../../') to import any of your components.

How?

Install required dependencies

npm i babel-plugin-module-resolver metro-react-native-babel-preset

Head over to your babel.config.js file in your project root directory. (If it doesn't exist, create it)
Add the module-resolver plugin to your plugins array like this:

module.exports = {
    presets: ['module:metro-react-native-babel-preset']
    plugins: [
        [
            'module-resolver',
            {
                root: ['.'],
                extensions: ['.ios.js', '.android.js', '.js', '.ts', '.tsx', '.json'],
                alias: {
                    '@': './src/components',
                    'constants': './src/constants',
                    '##': './src/examples',
                },
            },
        ]
    ]
};

Make sure to provide the path you want to reference with an alias, and the alias name itself.

According to the example above now you're able to import files or modules like this

import MyComponent from '@/MyComponent.js'
import MyConstantFile from 'constants/myConstant.js'
import MyExample from '##/MyExample.js'

I would love to engage with other developers like you. Get in touch on Twitter! @dev_astador

VSCode Shortcuts✂️ - Toggle Terminal: Redefined

Andres Urdaneta — Tue, 25 May 2021 18:34:42 +0000

I always hated the shortcut that VSCode gives you to toggle your integrated terminal:

ctrl + `

Feels uncomfortable on the left hand. I have found myself moving my hands away many times from the home row keys. And even worse: Looking down at the keyboard to make sure I don't miss any of these keys (ctrl + `).

Home row keys Left hand: A, S, D Right hand: J, K, L

The integrated terminal happen to be one of the most useful tools that and Text Editor for programming can offer. It's an essential need.

So, instead of using such uncomfortable shortcut that clutters your fingers to toggle your terminal you'd better consider using from now on:

cmd + j

It gives me such a pleasure to toggle my integrated terminal with this shortcut. It just feels natural. Like a breeze.
The way it should be considering that it's probably an day-to-day-every-five-minute shortcut that you'd use.

Note that this shortcut (cmd + j) isn't covered by the VSCode documentation (at least I couldn't find it), neither appears in the View dropdown menu in your VSCode.

Well... Hope that this little shortcut helps you in your day to day development life.

Do you have any cool shortcuts you want to share with me? Drop out your shortcuts on Twitter! @dev_astador

Como hacerle debug a Redux en React Native

Andres Urdaneta — Mon, 15 Feb 2021 23:31:44 +0000

Nota: Puedes leer este articulo en ingles, haciendo click aqui

Despues de mucho s u f r i r tratando de entender como estas dev tools trabajan en conjunto para hacerle debug a la primera aplicacion en React Native que me han asignado, llegue a estar tan estresado por no ser capaz de saber que se encontraba dentro de mi Redux Store State que decidi documentar la solucion que me funciono.

Despues de todo no fue tan complicado, solamente que la documentacion no era lo suficientemente clara para mi...

No voy a explicar los fundamentos de como instalar y configurar un Redux Store con sus middlewares, pero puede seguir este articulo si necesitas aprender como hacerlo.

Dicho esto...

En este blog voy a ensenarte como hacerle debug a una aplicacion en React Native utilizando la extension de Chrome: Redux DevTools Extension.

Instalando las dependencias necesarias

Vamos a instalar las siguientes dependencias:

React-native-debugger: Esta es una standalone app que vamos a instalar utilizando brew. Abre tu terminal y corre el siguiente comando:

brew install --cask react-native-debugger

Redux DevTools Chrome Extension && redux-devtools-extension Esta es una herramienta que vas a necesitar instalar como una extension de Chrome en tu navegador Google Chrome y tambien como una dependencia en tu proyecto.

Primero, ve hacia el Chrome Web Store e instala Redux DevTools.
Ahora, finalmente dirigete hacia el root de tu proyecto para instalar las dependencias siguientes:

npm install redux-devtools-extension

npm install remote-redux-devtools

Una vez finalizada la instalacion de estos paquetes, veamos el archivo donde hemos configurado previamente nuestro Redux Store, comunmente llamado configureStore.js o store.js.

Configurando nuestro R e d u x S t o r e

Si no estas utilizando middleware and enhancers entonces tu Redux Store deberia verse mas o menos como esto:

// configureStore.js

import { createStore, applyMiddleware, compose } from 'redux’;

const store = createStore(reducer, compose(
  applyMiddleware(...middleware),
  // other store enhancers if any
));

Si, por el contrario, estas utilizando un middleware and enhancers como redux-thunk, o alguno similar: Utilicemos el modulo composeWithDevTools que proviene del paquete redux-devtools-extension, y nuestro store se veria algo asi:

// configureStore.js

import { createStore, applyMiddleware } from 'redux';
import { composeWithDevTools } from 'remote-redux-devtools';

const store = createStore(
    reducer,
    composeWithDevTools(applyMiddleware(...middleware),
  // other store enhancers if any
));

En el primer ejemplo no fue necesario utilizar el modulo composeWithDevTools. Esa es la unica diferencia entre los dos snippets de codigo. Asegurate solamente de que estas utilizando la manera correcta para tu proyecto.

Corriendo la herramienta `React Native Debugger`

Hay dos maneras de acceder al React Native Debugger, y las dos son bastante parecidas, es solo cuestion de cual prefieres:

React Native Debugger corre por defecto en el puerto local 8081, asi que puedes simplemente abrir tu terminal y correr el siguiente comando:

open “rndebugger://set-debugger-loc?host=localhost&port=8081”

Dirigete hacia el directorio root de tu proyecto y abre el package.json. En la seccion de "scripts" agrega lo siguiente:

  ”debug": "open 'rndebugger://set-debugger-loc?host=localhost&port=8081’”

Ahora, el package.json deberia lucir mas o menos asi:

  "scripts": {
      "android": "react-native run-android",
      "ios": "react-native run-ios",
      "start": "react-native start",
      "test": "jest",
      "lint": "eslint .",
      "debug": "open 'rndebugger://set-debugger-loc?host=localhost&port=8081'"
    }

Luego, hecho esto, en tu directorio root corre el siguiente comando:

npm run debug

Esto deberia abrir la ventana de React Native Debugger.

## Acceso al Developer Menu

Una vez lanzado el React Native Debugger, dirigete hacia tu el editor de texto donde tienes tu proyecto y lanza tu aplicacion en el simulador de dispositivo, en mi caso:

Para iOS

npm run ios

Para Android

npm run android

Una vez abierto, utilizando el shortcut cmd+d en el simulador de iOS, cmd+m si estas utilizando el simulador de Android. El Developer Menu deberia abrir. Selecciona la opcion Debug.

Y Voilà!

Esto deberia conectar tu RNDebugger con tu aplicacion. Ahora tienes la posibilidad de hacerle a tu aplicacion utilizando el Chrome DevTools pero tambien la razon por la que viniste aqui, para chequear y saber que hay en tu Redux Store.

PD: Let's connect on Twitter! @dev_astador

How to Debug Redux in a React-Native App

Andres Urdaneta — Mon, 15 Feb 2021 00:07:39 +0000

Note: You can read this article in spanish

After a lot of —s t r u g g l e— trying to understand how all these dev tools work together in order to debug my first React Native Application I got so stressed for not being able to just get to know what was in my Redux Tree that I decided to document the solution that worked for me.

— After all it wasn't that complicated, it's just that the docs weren't clear enough for me... and you know when you just go nuts with something simple? Well... —

That being said…

In this blog I'm going to show you how to debug a React Native application using the Chrome Extension: Redux DevTools Extension.

Assuming that you already have your React Native project set up with Redux and a middleware (i.e thunk). (I mean, installed as dev dependencies and your Redux store already setup);

Installing needed dependencies

We are going to install the following dependencies:

React-native-debugger:
This is a standalone app that you are going to need to install with brew

brew install --cask react-native-debugger
Redux DevTools Chrome Extension && redux-devtools-extension
This is a tool that you are going to need to install as a Chrome Extension in your Chrome Web Browser and also as a dev dependencie in your project.

First, head over to the Chrome Web Store and install the Redux DevTools.
Then, now and finally we’ll head to the root of our project and install the dev dependencies:

npm install redux-devtools-extension remote-redux-devtools

Once finished installing the dependencies mentioned above we’ll take a look at the JavaScript file where we configure our redux store. Commonly named as configureStore.js or store.js.

Configuring our R e d u x S t o r e

If you setup your store with middeware and enhancers like redux-thunk, or similar: Let's use the composeWithDevTools export from redux-devtools-extension, and our store would look more or less like this:

// configureStore.js

import { createStore, applyMiddleware } from 'redux';
import { composeWithDevTools } from 'remote-redux-devtools';

const store = createStore(
    reducer,
    composeWithDevTools(applyMiddleware(...middleware),
  // other store enhancers if any
));

If you are not using middleware and/or enhancers then your store should look like this:

// configureStore.js

import { createStore, applyMiddleware, compose } from 'redux’;

const store = createStore(reducer, compose(
  applyMiddleware(...middleware),
  // other store enhancers if any
));

Notice that in the second example we don’t need to use the composeWithDevTools export. That’s the only difference. The reason behind this is that the composeWithDevTools function makes the actions dispatched from Redux DevTools flow to the middleware (something to take a deep look if you want to go down that rabbit hole).

Launching the `React Native Debugger`

There are two ways of accessing the React Native Debugger and they both are kinda the same, it’s just matter of preference:

The React Native Debugger runs by default in the port 8081, you can just open your terminal and run the following command:

open “rndebugger://set-debugger-loc?host=localhost&port=8081”

or
Head over to your app root directory and open the package.json. In the“scripts” section add the following:
```
”debug": "open 'rndebugger://set-debugger-loc?host=localhost&port=8081’”
```

By now your package.json should look something like this:

"scripts": {
    "android": "react-native run-android",
    "ios": "react-native run-ios",
    "start": "react-native start",
    "test": "jest",
    "lint": "eslint .",
    "debug": "open 'rndebugger://set-debugger-loc?host=localhost&port=8081'"
  }

And then in your app root directory run the following command:

npm run debug

This should open the React Native Debugger window.

Accesing the Developer Menu

Once launched the React Native Debugger head over to your project in your text editor and launch your app in the device simulator (in my case npm run ios or npm run android). Once the app opened, by using the shortcut cmd+d in the iOS simulator or cmd+m when running in an Android emulator, the Developer Menu should open. Click the “Debug” option.

And Voilà!

This should get your RNDebugger connected with your application. Now you are able to debug your app overall by taking advantage of the Chrome DevTools but also the reasons you came here... To check and debug your freaking Redux Tree.

DEV Community: Andres Urdaneta

How to Fix Random OpenAI 500 Errors in Rails Background Jobs Using retry_on

Introduction

The Problem: A Failing Background Job

The Solution: Automatic Retries with Active Job

Step 1: Add Retries to the Job

Step 2: Improve Error Logging

Conclusion

How to Build AI-Generated Loading Messages in Rails 8 with Hotwire & Stimulus

Before we start: What are we using?

Step 2. Set up a resource controller

3. Build the user interface

4. Hard-coded loading phrases

Step 5. Simulating a long-process background job

6. AI-Generated loading phrases with RubyLLM

Conclusion

How I Run My SaaS for $45/month Without Supabase, Vercel, or Firebase. Just Rails.

The Stack

The Costs

SQLite3 is my database

No Redis. I'm fine.

Why not serverless?

Final thoughts!

Classify & Label Customer Service Chats with Python, OpenAI and Langchain

Create The Project Directory

Installing Dependencies

ENVs & Chat Text File

Getting Started

The Classification Schema

Structured Outputs

Wrap-up & Next Steps

How to change App ID/Package Name for Android app built with React Native

Change Package Name / Application ID in Android app built with React Native.

Stop using relative paths in your React Native imports. Use Aliases instead.

Use Aliases in your imports with Babel

How?

VSCode Shortcuts✂️ - Toggle Terminal: Redefined

Como hacerle debug a Redux en React Native

Instalando las dependencias necesarias

Configurando nuestro R e d u x S t o r e

Corriendo la herramienta React Native Debugger

How to Debug Redux in a React-Native App

Installing needed dependencies

Configuring our R e d u x S t o r e

Launching the React Native Debugger

Accesing the Developer Menu

Corriendo la herramienta `React Native Debugger`

Launching the `React Native Debugger`