DEV Community: Kristian-Roopnarine

Kitchen Nightmares: LangChain agents edition

Kristian-Roopnarine — Thu, 25 Jun 2026 12:55:00 +0000

TLDR?

Health application to parse recipes, create meals and meal plans
Implemented agents using LangChain and LangSmith for agent observability, FastAPI and React for web app
How using LangSmith can help diagnose agent bugs
I fired the idiot sandwich agent

Who doesn't love a good home cooked meal?

Over the last couple of years, cooking has been something I've grown to love. I enjoy cooking great food for my fiancé and finding recipes that I can share with my family and friends. The hard and annoying part sometimes is sharing that recipe, either I can't find the link or I changed something I did in the recipe and I've forgotten. Maybe its a memory problem instead…

Oh well, I'm an engineer so the only solution I know of is to buy a domain, build a side project and never ship it.

At first I created a script that will fetch the recipe details and save them in a Postgres database. It solved the problem of finding these recipes again, it was just a select query to get the information, but another problem I had was handling different "recipe components". Some recipes included multiple dishes like a main, side, sauces etc. The parsed recipe contents would provide a list of the ingredients and instructions for ALL the components. There were times where I only made the main dish of one recipe, and the side dish of another so this automation still didn't solve the problem, that's where I had an idea that I GUARANTEE nobody else has had.

What if I throw AI at this?

Genius right? Claude thought so too.

The idea is a FastAPI/React project that uses LangChain for agent invocation, and LangSmith for observability. The backend programmatically parses a recipe, then passes that in a prompt to a grouping agent which will find the different recipe components such as main, side, veggie, sauce etc and will group those components with their respective ingredients and instructions. There's a second structuring agent that will take the output from the grouping and create a structured response sent to the UI. I can then create a meal and/or meal plan using those components, calculate calorie information, mix and match components to create different meals and share the components or meal plan with others. Example of the UI shown below. It includes the inconsistent output. Notice the main dish doesn't have instructions!

The idiot sandwich agents

I am using 2 agents for the recipe extraction. One agent is responsible for grouping and generating the components, the other is responsible for just providing the structured output from the grouping agent. These are the bones of the dual agent execution:

def execute(url: str) -> ParsedRecipeComponentResponse:
    tracker = AgentMetadataTracker()

    grouping_prompt = (
    )
    grouping_agent = create_agent(model="claude-haiku-4-5", tools=[recipe_fetch])
    grouping_result = grouping_agent.invoke(
        {
            "messages": [
                {
                    "role": "system",
                    "content": grouping_prompt,
                },
                {"role": "user", "content": url},
            ]
        },
        config={"callbacks": [tracker]},
    )

    structuring_agent = create_agent(
        model="claude-haiku-4-5",
        tools=[],
        response_format=ParsedRecipeComponentResponse,
    )
    structuring_prompt = (

    )
    result = structuring_agent.invoke(
        {
            "messages": [
                {
                    "role": "system",
                    "content": structuring_prompt,
                },
                {"role": "user", "content": grouping_result["messages"][-1].content},
            ]
        },
        config={"callbacks": [tracker]},
    )

    sr = result["structured_response"]
    return sr

I already know what you're thinking. Why two agents? At first, when I tried to use one agent to do the grouping and produce the structured output, it was very unreliable. Sometimes the agent would generate duplicate components, two main dishes with one having all the ingredients and the other all the instructions. Sometimes the agent would forget the instructions in the output all together (shown in picture above), and other times it would just combine the entire recipe into one component.

I then split it into two focused agents, one to group the recipes and one to just create the structured output. The funny thing is that this worked perfectly for the first day. After splitting the agent execution it worked really well, but when I went to implement the API call into the UI the NEXT DAY, the inconsistencies started showing up again. I was using print statements to try and debug the issues, which got quite annoying and that's when I learned about LangSmith. It's an observability platform that is agentic framework agnostic but integrates really easily with LangChain agent invocation.
Using LangSmith, I am able to track the token cost, input/output per agent execution. Which is perfect because I created a "tracker" shown in the code above to try and monitor these metrics already, and its no longer needed.

In the LangSmith tracing, it shows the latency, tokens and even cost! This will help when I try to optimize agent execution, can't improve what you don't measure. From the agent input/output I was able to assess that the grouping agent was working as expected. I saw the exact markdown output with the instructions and ingredients for each component, example shown below parsed from https://nickskitchen.com/halal-chicken-recipe/:

Based on the recipe I retrieved, here are the distinct components of the Halal Chicken and Rice recipe:

## MAIN DISH: Marinated Halal Chicken

### Ingredients:
- ½ cup plain whole-milk yogurt
- 3 tablespoon neutral oil (canola or avocado)
- 1 tablespoon white vinegar or lemon juice
- 6 clove garlic (finely grated)
- 2 teaspoon ground cumin
- 2 teaspoon ground coriander
- 2 teaspoon dried oregano
- 1½ teaspoon smoked paprika
- 1 teaspoon black pepper
- 2 teaspoon kosher salt
- ½ teaspoon ground turmeric
- ½ teaspoon ground ginger
- 2 pound boneless, skinless chicken thigh

### Instructions:
1. In a large bowl, whisk together the yogurt, oil, vinegar or lemon juice, garlic, spices, and salt until smooth.
2. Add the chicken and toss to coat completely.
3. Cover and refrigerate for at least two hours, preferably overnight.
4. Heat a cast-iron skillet or grill over high heat.
5. Cook the chicken in batches for five to seven minutes per side until deeply browned with slight charring. Cook until the internal temperature reaches 165°F (74°C).
6. Transfer to a cutting board and rest for 10-15 minutes.

---

## SIDES: Yellow Rice

### Ingredients:
- 2 cup long-grain white rice
- 2 cup chicken stock
- 1 tablespoon butter
- ½ teaspoon ground turmeric
- 1 teaspoon cumin seeds
- 1 bay leaf
- ¼ teaspoon garlic powder (optional)
- 1 teaspoon kosher salt

### Instructions:
1. Rinse the rice in a fine mesh strainer until the water runs mostly clear.
2. Add the rice, chicken stock, butter, turmeric, cumin seeds, bay leaf, garlic powder, and salt to a rice cooker or pot.
3. Cook using the white rice setting or simmer covered until tender.
4. Fluff with a fork and keep warm.

---

## SAUCES: White Sauce (Garlic Yogurt)

### Ingredients:
- 1 cup mayonnaise
- ½ cup plain Greek yogurt
- 2 tablespoon lemon juice
- 2 tablespoon white vinegar
- 4 clove garlic (finely grated)
- 1 tablespoon sugar
- 1 teaspoon black pepper
- 1 teaspoon salt
- 1 teaspoon dried dill
- 1 teaspoon dried tarragon

### Instructions:
1. Whisk all ingredients together in a bowl until smooth.
2. Add a little cold water if needed to thin to a pourable consistency.
3. Transfer to a squeeze bottle (optional) and refrigerate for at least two hours, preferably overnight.

---

## SAUCES: Red Sauce (Hot Chile)

### Ingredients:
- 6-8 dried red chiles (chile de árbol or similar)
- 4 clove garlic
- 1 tablespoon white vinegar
- 1½ teaspoon paprika
- ½-1 teaspoon cayenne pepper (to taste)
- 1 teaspoon kosher salt
- ½ cup neutral oil

### Instructions:
1. Soak the dried chiles in boiling water for ten minutes.
2. Add softened chiles, garlic, vinegar, paprika, cayenne, and salt to a blender and blend until smooth.
3. With the blender running, slowly stream in the oil to emulsify.
4. Add soaking liquid as needed to thin.
5. Transfer to a squeeze bottle and chill for at least two hours.

---

## SALADS: Lettuce and Tomato Salad

### Ingredients:
- iceberg lettuce (finely shredded)
- ripe tomatoes (thinly sliced)

### Instructions:
1. Finely shred the lettuce and thinly slice the tomatoes.
2. Refrigerate until ready to serve to keep crisp.

---

## BREAD: Pita Bread

### Ingredients:
- pita bread (warmed)

### Instructions:
1. Warm the pita in a dry pan or oven until soft and lightly toasted.

This is EXACTLY what I expect from the grouping agent and the structure agent receives this input too, but somehow doesn't consistently produce the correct output. Here is the output from the structuring agent with the above input:

{"components": 
  [
    {"name": "Marinated Halal Chicken", 
    "cuisine": "Middle Eastern", 
    "source": "https://nickskitchen.com/halal-chicken-recipe/`, "
    }, 
    {"name": "Yellow Rice", "cuisine": "Middle Eastern", "source": "https://nickskitchen.com/halal-chicken-recipe/`, "}, 
    {"name": "White Sauce (Garlic Yogurt)", "cuisine": "Middle Eastern", "source": "https://nickskitchen.com/halal-chicken-recipe/`, "}, 
    {"name": "Red Sauce (Hot Chile)", "cuisine": "Middle Eastern", "source": "https://nickskitchen.com/halal-chicken-recipe/`, "}, 
    {"name": "Lettuce and Tomato Salad", "cuisine": "Middle Eastern", "source": "https://nickskitchen.com/halal-chicken-recipe/`, "}, 
    {"name": "Pita Bread", "cuisine": "Middle Eastern", "source": "https://nickskitchen.com/halal-chicken-recipe/"}]
}

In this example the instructions and ingredients are COMPLETELY missing, when this is the expected structured response:

class RecipeComponent(BaseModel):
    """Parsed Recipe Information"""

    name: str = Field(description="Name of the recipe component")
    cuisine: str = Field(
        description=(
            "Cuisine type inferred from the recipe "
            "(e.g. 'Indian', 'Mexican', 'Italian'). "
            "Use 'Unknown' if it cannot be determined."
        )
    )
    instructions: List[str] = Field(
        default_factory=list,
        description="List of instructions for this recipe component",
    )
    ingredients: List[str] = Field(
        default_factory=list,
        description="List of ingredients for this recipe component",
    )
    source: str = Field(description="Source of where this recipe component was parsed")

class ParsedRecipeComponentResponse(BaseModel):
    components: List[RecipeComponent] = Field(
        description="List of components parsed from the recipe"
    )

I have to fix these idiot sandwiches now, and it's definitely my fault. Thankfully with LangSmith I can help identify which agent is causing the issue, and whether I even need 2 agents at all.

What's next

First I want to fix the agent reliability - I noticed that the structured output contains a cuisine field that isn't part of my original prompt for the grouping agent, and isn't included in the markdown output. I wonder if this causes the structuring agent to become an idiot sandwich.
Adding LLM validation - I'm familiar with the LLM-as-a-judge pattern for output verification, but I feel like what would be overkill in this situation. I should be able to create a python function to validate the outputs, ensure the markdown is in the correct format and that the structured response does not contain duplicates etc.
Improving Observability - I want a metric that links all agent executions to a parsing event. When a user triggers some parsing event, I want to be able to trace every aspect of that request.

How to separate your test, development and production databases using NODE_ENV.

Kristian-Roopnarine — Fri, 27 Nov 2020 18:22:42 +0000

Why should you separate your test, development and production databases?

As your applications become more complex you're going to incorporate different methods of testing to help ensure that your application works as intended. Of course this doesn't make your application 100% bullet proof, which is why proper testing is important, but why is it important to separate our testing environment from development and production? When running test suites, there is usually some degree of changes made to the database in the form of updating entries, adding, deleting, forcing errors etc. We want to make sure that when we run our tests, they don't rely on previous data to ensure that one test doesn't influence another. An easy way to do this is to implement some clean up method before and after a test is run, which usually means clearing a database and filling it with the same dummy data.
Running a test suite on a production database would be irresponsible because a test might have unwanted side effects and alter the state of our database, or worse it would reveal information about our tests and source code. The data inside of the production database is always changing as well, which means that a test suite might work one day, but fail another day because the same data was altered causing our tests to fail.

How to separate application environments using NODE_ENV

We can store environment variables in the node process (highly encourage you to read up on this if you're not familiar). Then we can access any of these variables in any part of our program. These variables are also secure so it is common to store API keys, credentials and other secrets inside of the node process. When running our node applications we can set the NODE_ENV and conditionally change the applications settings based on this NODE_ENV. It is a common practice to store these variables as key=value pairs inside of a .env file shown below.

The environment is set to development by default and one implementation of this is found below by changing our the URI to our database.

This does not have to be used with mongoose, it was just an example. But depending on the environment our application will use a different database. This can be used to change the settings of other features as well, maybe you want to enter a testing environment for stripe, or sandbox environment to test an SDK.

How to set NODE_ENV

Now that we know how to conditionally render settings using NODE_ENV, how do we set NODE_ENV when running our application? A common approach is to set them in package.json scripts:

{
  ...
  "scripts": {
    "start": "NODE_ENV=production node ./app"
  }
  ...
}

This way you can start an app in either a test, development or production environment.

Add docker to your NodeJS workflow in just 4 simple steps

Kristian-Roopnarine — Wed, 18 Nov 2020 09:13:17 +0000

What is docker and why should you use it?

Docker is a platform as a service which allows you to isolate an entire operating system via Linux containers. The files we create below are instructions for how Docker should build the Linux container. Dockerizing (is that a word?) your application should be the first step in your workflow as it provides a good base for your development and production environments. Onboarding new members to the project is easy too, just provide them the respective Dockerfile and they’re good to go. Docker can become extremely complicated and you can add a lot of configuration to your application with Docker alone.

You will definitely benefit from spending time researching complex features of Docker!

Add docker to your NodeJS app in 4 steps

I don’t explain what the following code does, but docker has great documentation on it, https://docs.docker.com/engine/reference/builder/ .
All of the following config files will be at the root of your project. These files will work for probably 90% of your NodeJS applications, barring specific configuration.
If this is an application that will be shipped to production, create a separate Dockerfile.prod that contains configuration for your production application. These config settings can be googled because there are many people who have used Docker in production. This helps separate dev vs prod configuration with ease.

Create a Dockerfile.dev with the following code:

Create a docker-compose.yml with the following code:

Create a .dockerignore and add node_modules to it. Any files/folders in the .dockerignore will not be copied over to the Docker container. Since node_modules is usually a large directory, adding this to a .dockerignore this will speed up your build times. Add other files/directories you do not want to be copied into your docker container here!

Execute the following commands in the root directory of your project depending on what you need:

docker-compose up -d --build : Builds the container using Dockerfile.dev and starts your docker container in detached mode
docker-compose up -d Starts your docker container in detached mode
docker-compose down ALWAYS run this command when stopping your container
docker ps Lists your current active containers

After the initial build is successful execute docker ps and ensure that your container is running. If so, head on over to localhost:5000 where your application is hosted locally. You can change this port through the port setting in the docker-compose.yml .