Instalación de LangChain

Instalar Python

Para comenzar a trabajar con LangChain, el primer paso fundamental es tener Python instalado en tu sistema. LangChain es un framework moderno que aprovecha las características recientes del lenguaje, por lo que se recomienda utilizar una versión actualizada.

Asegúrate de tener instalada la versión 3.10 o superior de Python. Puedes verificar la versión actual instalada en tu máquina ejecutando el siguiente comando en tu terminal:

• Verificar la versión de Python:

python --version

Si no tienes Python instalado o necesitas actualizarlo, visita el sitio web oficial de Python.org y descarga la última versión estable compatible con tu sistema operativo.

Crear entorno virtual

El uso de entornos virtuales es una práctica esencial en el desarrollo con Python. Nos permite aislar las dependencias de nuestro proyecto, evitando conflictos con otras librerías instaladas en el sistema global o en otros proyectos.

Para crear un entorno virtual, navega hasta la carpeta de tu proyecto en la terminal y ejecuta el módulo venv de Python. Es común llamar a la carpeta del entorno .venv o venv.

• Crear el entorno virtual:

python -m venv .venv

En caso de tener varias versiones de python instaladas puedes indicar la versión exacta que quieres utilizar así al crear en environment:

py -3.14 -m venv .venv

Una vez creado, debes activar el entorno para que las instalaciones de paquetes se realicen dentro de él. El comando varía según el sistema operativo.

• Activar en Windows:

.venv\Scripts\activate

• Activar en macOS y Linux:

source .venv/bin/activate

Al activarlo, verás que el nombre de tu entorno aparece entre paréntesis al inicio de la línea de comandos, indicando que estás trabajando dentro del entorno aislado.

Instalar dependencias

LangChain adopta una arquitectura modular para ser más ligero y flexible. A partir de las versiones recientes, el ecosistema se divide en varios paquetes clave, lo que permite instalar solo lo necesario.

El paquete principal es langchain, que actúa como punto de entrada y contiene las cadenas y agentes básicos. Para instalarlo, utilizamos el gestor de paquetes pip.

• Instalar el paquete principal de LangChain:

pip install langchain

Además del núcleo, es muy probable que necesites integrar modelos de lenguaje externos (LLMs) o herramientas específicas. Estas integraciones suelen residir en paquetes separados de la comunidad o de proveedores oficiales.

Por ejemplo, si planeas utilizar los modelos de OpenAI (como GPT-4), debes instalar su paquete de integración específico. Esto garantiza que tengas las dependencias exactas para ese proveedor.

• Instalar la integración de OpenAI:

pip install langchain-openai

También existe el paquete langchain-community, que alberga una gran cantidad de integraciones mantenidas por la comunidad para diversas herramientas y servicios.

• Instalar integraciones de la comunidad:

pip install langchain-community

Finalmente, para verificar que la instalación se ha realizado correctamente y ver qué versiones de los paquetes tienes instaladas, puedes utilizar el comando pip freeze o consultar los detalles del paquete.

• Verificar los paquetes instalados:

pip show langchain

Como recomendación, puedes crear un archivo requirements.txt y declarar en él las librerías que vas a usar, por ejemplo:

langchain
langchain-openai
langchain-anthropic
langchain-google-genai
langchain-text-splitters
langchain-azure-ai
langchain-community
langchain-ollama
langchain-experimental
langchain-huggingface
langchain-postgres
langchain-chroma
langchain-tavily
langgraph
langgraph-checkpoint-postgres
langgraph-checkpoint-sqlite

Para instalarlas de golpe ejecuta el comando:

pip install -r requirements.txt

Verificación del entorno

Una vez completada la instalación, es importante verificar que todos los componentes están correctamente configurados. LangChain proporciona información útil sobre las versiones instaladas que facilita la depuración de problemas.

Comprobar versiones instaladas

Para confirmar que los paquetes se han instalado correctamente, puedes ejecutar un script de verificación:

import langchain
print(f"LangChain versión: {langchain.__version__}")

# Verificar integraciones instaladas
try:
    import langchain_openai
    print(f"langchain-openai: {langchain_openai.__version__}")
except ImportError:
    print("langchain-openai no instalado")

try:
    import langchain_anthropic
    print(f"langchain-anthropic: {langchain_anthropic.__version__}")
except ImportError:
    print("langchain-anthropic no instalado")

Configuración de variables de entorno

La mayoría de integraciones con proveedores de modelos requieren claves de API que deben configurarse como variables de entorno. La forma más segura es utilizar un archivo .env junto con la librería python-dotenv:

pip install python-dotenv

Crea un archivo .env en la raíz de tu proyecto con las claves necesarias:

OPENAI_API_KEY=tu_clave_openai
ANTHROPIC_API_KEY=tu_clave_anthropic
GOOGLE_API_KEY=tu_clave_google

Y cárgalas al inicio de tu script:

from dotenv import load_dotenv
load_dotenv()

Es fundamental añadir el archivo .env al .gitignore de tu proyecto para evitar subir credenciales a repositorios de código.

Primer test de funcionamiento

Para validar que todo funciona correctamente, ejecuta una invocación básica al proveedor que hayas configurado:

from langchain.chat_models import init_chat_model
from dotenv import load_dotenv

load_dotenv()

model = init_chat_model("gpt-5.4-mini")
response = model.invoke("Responde solo con 'OK' si recibes este mensaje.")
print(response.content)

Si recibes una respuesta del modelo, el entorno está correctamente configurado y puedes proceder con las siguientes lecciones del curso.

Estructura recomendada del proyecto

Para mantener un proyecto LangChain organizado, se recomienda seguir una estructura de directorios clara desde el inicio:

mi_proyecto_langchain/
├── .env                    # Variables de entorno (API keys)
├── .gitignore              # Incluir .env y .venv
├── requirements.txt        # Dependencias del proyecto
├── main.py                 # Punto de entrada principal
├── tools/                  # Herramientas personalizadas
└── .venv/                  # Entorno virtual

Esta organización facilita la colaboración en equipo y el despliegue en producción, separando claramente la configuración de la lógica de la aplicación.