FORMACIÓN LANGCHAIN: CREA APLICACIONES IA QUE FUNCIONAN DE VERDAD

We start with the basics. Understanding LangChain's architecture, setting up the environment, and making your first calls.

You'll configure your Python project, connect different LLMs (OpenAI, Anthropic, open-source models), and understand the difference between LangChain, LangChain Expression Language (LCEL), and LangServe.

We'll see how to structure prompts with PromptTemplates, parse outputs properly, and handle API errors.

At the end of this module, you have a functional dev environment and know how to make structured LLM calls with LangChain.

The core of LangChain: chains. We learn to create modular and reusable prompt pipelines.

You'll master LCEL (LangChain Expression Language), the new syntax for creating chains. It's cleaner, more readable, and easier to debug than the old method.

We'll see how to chain multiple prompts, pass data between steps, and create conditional branches with RunnableBranch.

You'll also learn to create parallel chains to optimize speed, and manage streaming for real-time responses.

At the end, you know how to build complex LLM workflows in a clean and maintainable way.

The most requested use case: making an LLM talk about your own documents. We implement RAG from A to Z.

You'll learn to load documents (PDF, Word, web pages, databases), split them into intelligent chunks, and transform them into embeddings.

We connect to vector stores: Pinecone for production, Chroma for local dev, and we'll see the differences. You'll learn to create efficient retrievers and optimize result relevance.

We implement different RAG strategies: basic retrieval, multi-query, self-query, and contextual compression.

At the end, you know how to create a chatbot capable of answering based on any document base with cited sources.

We move to the next level: agents. LLMs capable of reasoning and using tools.

You'll understand how LangChain agents work: the thought-action-observation cycle, different agent types (ReAct, OpenAI Functions, Plan-and-Execute).

We create custom tools: API calls, database queries, web search, code execution. You'll learn to define tools properly so the agent knows when to use them.

We also see the limitations: when an agent loops, when it hallucinates about tools, and how to handle these cases.

At the end, you know how to create autonomous agents capable of accomplishing complex tasks using multiple tools.

A chatbot without memory is frustrating. We implement different types of memory for coherent conversations.

You'll discover the options: ConversationBufferMemory (simple but greedy), ConversationSummaryMemory (automatic summary), ConversationTokenBufferMemory (token limit), and VectorStoreRetrieverMemory (long-term memory).

We'll see how to choose the right type according to your use case and API cost constraints.

You'll also learn to persist memory in databases like Supabase for conversations that survive restarts.

At the end, your chatbots remember the context and can have natural conversations over time.

Coding a prototype is good. Deploying to production is something else. We see everything needed to industrialize.

You'll learn to use LangSmith to trace every call, debug chains, and monitor performance. It's essential to understand what's happening in production.

We see how to optimize costs: caching embeddings, choosing models according to tasks, batching requests.

You'll learn to deploy with LangServe to expose your chains as APIs, and handle errors properly (rate limits, timeouts, retries).

At the end, you have a production-ready LangChain application with monitoring, logs, and a scalable architecture.