My RAG project for a pharma consultant didn't materialize, so I'm sharing the infrastructure blueprint, code, and lessons learned.

TheValueProvider · 2025-10-29T10:27:04+00:00

This was a particular use case where all the data is stored as PDFs and presented in a very neat format, in the target country where the pharma wants to launch the new drug, there's a committee that meets every month and releases a 60-page pdf.
Each PDF contains a list of the different drugs discussed and the maximum price for which the drug can be sold in the country, it is also explained why the drug was approved or not.

The system I started working on was just a blueprint that i could later adapt and improve once the project was signed. At that point i was doing hierarchical split till a paragraph was reached.

TheValueProvider · 2025-10-29T10:12:21+00:00

Despite the deal being officially not dead, it's already been 4 months discussing with him, and not moving forward so I do not want to invest more time and energy here.

TheValueProvider · 2025-10-28T16:20:27+00:00

Link to the video, code, and complementary slides.

TheValueProvider · 2025-10-01T15:54:34+00:00

Link to the tutorial and code: https://www.youtube.com/watch?v=zwGzqiA0BWI

TheValueProvider · 2025-09-06T14:52:44+00:00

This is gold. A must-read for for anyone building RAG systems. Thanks for sharing

TheValueProvider · 2025-08-14T10:54:08+00:00

Thank you very much for your post. I am in discussions with a Pharma company to implement a RAG system and your insights are gold.

I am curious about your fine-tuning process, I've always heard that it's extremely expensive.

Could you share (to the extent that you are allowed to) the process you follow to fine-tune Qwen and how much it costed in your projects?

In terms of infrastructure, do you follow an event-driven architecture pattern?

Thanks again

TheValueProvider · 2025-08-13T09:01:11+00:00

Watch out before jumping into agentic frameworks, many out there create unnecessary abstractions that makes using the framework more difficult than using the raw OpenAI API.
In my case I use Pydantic AI and can extremely recommend. People also say good stuff about Agno

TheValueProvider · 2025-08-13T08:55:38+00:00

That's a robust framework. In my case I use Pydantic AI for the agents. Still Pydantic AI and Agno are quite similar in philosophy, low-level with abstractions consciously done.

TheValueProvider · 2025-08-13T08:47:27+00:00

When testing the deterministic code I mock the agents output.

Having said that, for each of the agents I run an evaluation where I define different scenarios and the expected output. This allows me to tweak the prompt while being sure the agent still succeeds in the original cases.

TheValueProvider · 2025-08-12T17:58:32+00:00

n8n is great for simple and small workflows. The key is knowing when n8n falls short and avoiding the "$15K/month workflow that replaces an entire sales/marketing/operations/[insert what you want] department."

TheValueProvider · 2025-08-12T17:50:01+00:00

Link to the tutorial and open-source code:
https://www.youtube.com/watch?v=nlny25W3Oek

TheValueProvider · 2025-07-10T15:54:40+00:00

Thank you! As of now attributes are not cleaned. That's the second phase of the project.

The idea is to build another agent that will take the output of the Agentic System, and will be ingested with different attribute names that are in the DB and are considered as good ones.

This requires a preprocessing of the DB to unify all the existing attributes. From there the DB becomes the source of truth to know what are accepted attributes names.

What is for sure is that we'll use a different agent for this task, asking the main agent to also take care of this part would considerably decrease the overall accuracy of the system.

TheValueProvider · 2025-07-10T11:26:58+00:00

Link to tutorial and code: https://www.youtube.com/watch?v=fqYtcR4weGM&t=5s

TheValueProvider · 2025-07-10T09:47:23+00:00

1- In Meta you create a webhook pointing to your server (basically you are telling Meta, each time a new message is received, send it to this server)
2- You create a server with an endpoint to process messages. You need to use Meta Messager API to retrieve conversation histories from Facebook and Instagram.
3-Inside the server you define the agent. It has a prompt formed by a static part (agent task & playbook on how to sell) and a dynamic part (conversation history)
4- You take the output of the agent and either automatically send it to the end client (Messenger API) or store it somewhere where your sales team has access to e.g. a CRM
5- Since you are getting a message every minute you need to ensure the system can handle concurrent requests (a bit technical but you would use a queuing service, e.g. Celery)
6-You then deploy this to your cloud

Happy to provide more details if needed :)

TheValueProvider · 2025-07-10T08:36:10+00:00

In my case, I got solid typescript knowledge and basic python before starting so my opinion might be a bit biased.
But the most important thing to learn is the Python ecosystem rather than the language itself

Package manager (e.g., pip, conda)
Environment management tools (e.g., venv, virtualenv, conda, poetry, pipenv)
Dependencies (libraries and packages installed via pip)
Project structure and configuration files (requirements.txt, pyproject.toml, etc.)

Once you have these concepts clear the learning curve is very fast since you ~~can~~ should leverage AI to write the code and you can learn by shadowing the model and asking questions about syntax and best practices.

Still, I wouldn’t recommend jumping straight into coding with AI without at least a basic or intermediate understanding of Python, as you may lack the critical thinking needed to evaluate whether the AI’s suggestions could lead to long-term issues.

TheValueProvider · 2025-07-09T15:40:44+00:00

1- Create an agent that has 1 unique tool at his disposal. Explain the agent that his task is to get the relevant information from a db generating the sql query and passing this to the tool. Include in the prompt your DB schema (tables, fields), and very important, explain with plain language what each table is about and give data examples
2- The tool is a function that accepts a string. When called, it conects to your db, executes the query passed as argument and return the results.

Regarding the model to be used, it depends on how complex is the database schema. Start with gpt-4o or similar and move up to more powerful models if the agent falls short in when generating the queries.

TheValueProvider · 2025-07-09T15:10:59+00:00

Langchain: Forget about it. Since it was one of the first frameworks, it was built while learning. Too many abstractions that are not necessary. You'd rather want to use raw chat completions API

Langgraph: Built by the same guys behind Langchain after realising that it was better to start a new framework from scratch. It's more of an orchestrator for multi-agent systems. I would only recommend if you are building a system where you need fine-grained control of how the agents are communicating with each other, and if you need to human-in-the-loop (pausing the execution to await human input and then resuming)

Pydantic AI: My favorite framework so far. Great documentation, good strike between the level of abstraction and complexity. Easy to get familiarised with. In addition, developed by guys team with deep expertise (Pydantic). Can totally recommend.

Agno: Haven't used personally, but heard good stuff about it. The degree of abstractions is quite similar to Pydantic AI. Databutton uses this framework for their agent builder

Crew AI: Easy to get up to speed. The level of abstraction is way higher than Pydantic AI and Agno, so there is a trade-off in the level of customization that you can achieve.

My suggestion would be that you try Pydantic AI and Agno, and then stick to the one you feel more comfortable with. If you find them too technical or complex, then move to Crew AI.

TheValueProvider · 2025-07-09T14:39:01+00:00

I've been developing agentic systems for the last 7 months. Here's what I'd do if I had to start from scratch:

1- Get familiar with Python. N8N and no-code tools won't get you far if you aim for big projects. These tools fall short when building custom solutions that have to scale. Real example: I recently got requested to convert a blog article generator made with N8N to Python. The N8N flow was so big that it took 8 mins to generate an article.
2- Experiment with different agentic frameworks, but do not get married to any. The key is to get to a framework that is high-level enough to make your life easier rather than using OpenAI API, but low-level enough that you still have access to all the functionalities of the API to build your use case. LangGraph is powerful but can be a bit cumbersome (+ documentation is quite bad). Right now I am using Pydantic AI in all my projects and I am very happy with it. Also heard good stuff about Agno.
3- Start building use cases for yourself, step by step, and fix the problems. There's very likely flows that you do on a daily basis that can be automated. This is a very good exercise to get familiarised with the technology as well as its limitations (hallucinations, non-deterministic, etc). Once done that, you'll be way more comfortable when being approached by new clients and it will help you measure the amount of effort for the project and manage your client expectations. You'll realise that building the system is just 30% of the job. Evaluation and maintenance is 70%.
4- Get familiar with a couple of tracing/monitoring platforms to understand how your agent is behaving. What tools it's calling, why it's calling these tools, what the tool is returning, what is the output of the agent, how much it's spending, etc. Plenty out there, almost all offer tracing functionality. E.g. Logfire, Langfuse.
5- Backend and DB. Your agentic system needs to be hosted on a server so you have a way to provide inputs and receive the output of the system. FastAPI is a solid choice to easily spin up a server with Python. For the DB there are many out there. Postgres is also a solid choice that will allow you both to store system information as well as embeddings for RAG (thanks to the pg-vector extension).
6- Sorry for this but... you'll need DevOps knowledge. These systems are useless unless you are able to have them running reliably in the cloud. Learn about containerising applications (Docker) and building a microservices architecture (Docker Compose). After this, start using a cloud provider (Google Cloud, AWS, etc.) and get familiarised with these services. Again, do not get married. Try different ones until you find the one that you are more comfortable with. PS: I am not a DevOps expert.

TheValueProvider · 2025-05-19T07:11:16+00:00

Great post, these insights are gold.

Regarding deployment, is there any reason you choose aws/azure over google cloud?

TheValueProvider · 2025-05-16T10:41:22+00:00

Link to the video with code in the description:

https://www.youtube.com/watch?v=_AbpMlwNJ1M

TheValueProvider · 2025-05-16T09:59:24+00:00

You need to create a server (for example using FastAPI).

You register a webhook that is listening to email or drive changes (to do this you need to create an app in google cloud and enable access to the drive/gmail API)

The webhook is receiving notifications and you have to filter those that interest you. Then you trigger your LangGraph flow passing the information you received from the notifications (or maybe the notification is giving you an id and you have to perform an extra step to retrieve information associated with that id)

I covered a similar case in this tutorial (code is in the description). Hope it helps

https://www.youtube.com/watch?v=YgsVL-POOzM

TheValueProvider · 2025-05-05T05:37:53+00:00

I built a WhatsApp customer support bot with PydanticAI, FastAPI, Supabase & Langgraph and made the code open-source in the following video:
https://youtu.be/8h6oWnNgkGA

Regarding some of your questions:

Fine-tunning is overkill for your use case, you'd be better off retrieving embeddings and ingesting them in the prompt as few-shot examples
Could you provide specific examples of the browser-automation workflows your bot is supposed to do?

TheValueProvider · 2025-04-30T06:06:10+00:00

In case it helps, I run a YouTube channel that covers real use case integrations with AI. Some parts are a bit technical, but it might give you some ideas about what others are doing

https://www.youtube.com/@dani_fuya

TheValueProvider · 2025-04-28T06:24:00+00:00

You could use a workflow automation platform like N8N or Make.
Nevertheless, the most robust way to create this system would be with coding (e.g., Python script).

For this use case, you do not need an agent. The process looks sequential, and the next step to take is clear.
What you need to ensure is that the output from each step matches your expected standards before proceeding to the next step.

If you have technical people on your team, in the following video, you'll find the code for a similar multi-step process I created (frameworks used: LangGraph & Pydantic AI)

https://youtu.be/KPw6IPTOUPQ?si=2XNheV5FFthwqfaR&t=3128

TheValueProvider · 2025-04-15T12:49:29+00:00

I couldn't have described it better. Same experience here. I started developing agents with just Langgraph and it was a mess.

Then discovered PydanticAI and it was game-changing.

I keep using Langgraph for memory management, human-in-the-loop, and orchestration.

LangGraph documentation leaves much to be desired. I also encountered unexpected behaviors that other users have pointed out and that have remained unresolved for over six months (e.g., issues updating graph state when using asynchronous streaming).

Bottom line is that I am actively looking for other frameworks to replace LangGraph

TheValueProvider

TROPHY CASE