# How to Deploy a LangChain App in 2026 (Complete Guide)
> Deploy a LangChain app to production in 2026 without Docker or server config. Step-by-step guide covering FastAPI setup, env vars, and deployment on Kuberns.
- **Author**: priya-nambiar
- **Published**: 2026-05-05
- **Modified**: 2026-05-05
- **Category**: AI & DevOps
- **URL**: https://kuberns.com/blogs/deploy-langchain-app/
---
You built a LangChain app. It works on your machine. Now you need to get it live so users, your team, or another service can hit it over HTTP.
The problem is that LangChain is a Python library, not a server. It has no built-in HTTP transport. Getting it to production means wrapping it in a web framework, securing your API keys, and picking a platform that handles the infrastructure for you.
This guide covers the exact steps to deploy a LangChain app to production in 2026. No Docker, no YAML files, no server provisioning.
## What Is LangChain and Why Deployment Is Different
LangChain is an open source Python framework for building applications powered by large language models. It gives you prebuilt components for chaining LLM calls, connecting to tools, retrieving from vector databases, and running multi-step agents.
Unlike a typical Python web app, a LangChain app makes external API calls to model providers like OpenAI or Anthropic on every request. That means your production environment needs to handle longer request times, secure API key storage, and reliable uptime without cold starts interrupting a user mid-conversation.
The fastest way to cover all of that is deploying on [Kuberns](https://kuberns.com), the world's first agentic AI cloud platform, which reads your repository, detects your Python stack automatically, and gets your app live in under 5 minutes without any server configuration.
## Prerequisites
Before you deploy, make sure you have:
- A LangChain app wrapped in a FastAPI server (covered in the next section)
- A `requirements.txt` with your dependencies
- A `Procfile` with your start command
- Your project pushed to a GitHub repository
- An LLM API key (OpenAI, Anthropic, or whichever provider you use)
That is the complete list. No Docker, no server setup, no YAML files.
## Prepare Your LangChain App for Deployment
Kuberns needs three files at the root of your project. Here is exactly what each one should look like.
### main.py: Your FastAPI Server
LangChain chains and agents are Python objects. FastAPI wraps them in an HTTP server so they can be hit over the internet. It handles async natively and works with LangChain's streaming output out of the box.
```python
# main.py
from fastapi import FastAPI
from pydantic import BaseModel
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
import os
app = FastAPI()
prompt = ChatPromptTemplate.from_messages([
("system", "You are a helpful assistant."),
("user", "{question}")
])
llm = ChatOpenAI(
model="gpt-4o",
api_key=os.environ["OPENAI_API_KEY"]
)
chain = prompt | llm | StrOutputParser()
class QueryRequest(BaseModel):
question: str
@app.post("/ask")
async def ask(request: QueryRequest):
result = await chain.ainvoke({"question": request.question})
return {"answer": result}
@app.get("/health")
async def health():
return {"status": "ok"}
```
### Procfile: Your Start Command
```
web: uvicorn main:app --host 0.0.0.0 --port $PORT
```
Kuberns reads this and starts your server on the port it assigns. Nothing else to configure.
### requirements.txt: Your Dependencies
```txt
fastapi>=0.110.0
uvicorn>=0.29.0
langchain>=0.3.0
langchain-openai>=0.2.0
langchain-core>=0.3.0
pydantic>=2.0.0
```
Swap in your model provider package as needed:
```txt
langchain-anthropic>=0.3.0 # for Claude
langchain-google-genai>=2.0.0 # for Gemini
```
Push these three files to GitHub. That is everything Kuberns needs to deploy your app.
## How to Deploy a LangChain App on Kuberns (Step by Step)
[Kuberns](https://kuberns.com) is an agentic AI cloud platform built on AWS. It detects your Python runtime, installs dependencies from `requirements.txt`, starts your app using the Procfile command, provisions SSL, and manages auto-scaling without any configuration from you.
### Step 1: Create Your Kuberns Account
Go to [kuberns.com](https://kuberns.com) and click **Deploy for Free**. Sign up and verify your account. New accounts receive free credits to test your first deployment at no cost.
### Step 2: Connect Your GitHub Repository
On the **Creating a Service** page, connect your GitHub account and select your LangChain repository.
- Click **Connect and Configure** and authorize Kuberns
- Select the repository and the branch you want to deploy (typically `main`)
- Kuberns scans your project, detects Python from `requirements.txt`, and reads your start command from the Procfile automatically
### Step 3: Add Your API Keys as Environment Variables
Before clicking Deploy, go to the **Environment** section and add your secrets.
Click **Add Env Vars** to add them manually, or **Upload .env file** to import all at once. For a typical LangChain app:
| Variable | Description |
|---|---|
| `OPENAI_API_KEY` | Your OpenAI API key |
| `ANTHROPIC_API_KEY` | Your Anthropic key (if using Claude) |
| `LANGCHAIN_API_KEY` | Optional, for LangSmith tracing |
Kuberns encrypts all values and injects them at runtime. They never appear in build logs or deployment output.
### Step 4: Click Deploy
Click **Deploy**. Kuberns agentic AI takes over from here:
- Clones your repository from GitHub
- Installs all packages from `requirements.txt`
- Starts your server using the Procfile command
- Provisions compute on AWS in your selected region
- Issues an SSL certificate and assigns a live HTTPS URL
- Sets up CI/CD so every future push to the connected branch triggers an automatic redeploy
### Step 5: Your LangChain App is Live
Your app is live in under 5 minutes at a URL like `https://your-app.kuberns.app`. From the dashboard you can view live logs, monitor resource usage, update environment variables, and track AI-driven auto-scaling metrics.
Test it right away:
```bash
curl -X POST https://your-app.kuberns.app/ask \
-H "Content-Type: application/json" \
-d '{"question": "What is LangChain?"}'
```
## Handling Streaming Responses
LangChain supports streaming token-by-token output. If your app needs it, use FastAPI's `StreamingResponse` so users see output as it generates rather than waiting for the full completion:
```python
from fastapi.responses import StreamingResponse
@app.post("/ask/stream")
async def ask_stream(request: QueryRequest):
async def generate():
async for chunk in chain.astream({"question": request.question}):
yield chunk
return StreamingResponse(generate(), media_type="text/plain")
```
No additional platform configuration needed on Kuberns. Streaming works out of the box.
## Connecting a Vector Database for RAG
If your LangChain app uses Retrieval Augmented Generation, you need an external vector database accessible from the cloud. Add the connection details as environment variables in Kuberns and read them at runtime:
```python
from langchain_community.vectorstores import Pinecone
from langchain_openai import OpenAIEmbeddings
import os
embeddings = OpenAIEmbeddings(api_key=os.environ["OPENAI_API_KEY"])
vector_store = Pinecone.from_existing_index(
index_name=os.environ["PINECONE_INDEX"],
embedding=embeddings
)
retriever = vector_store.as_retriever(search_kwargs={"k": 4})
```
Add `PINECONE_API_KEY` and `PINECONE_INDEX` in the Kuberns environment section. No config files, no secrets in your code.
## LangChain Deployment Platform Comparison (2026)
| Platform | Auto-detects Python | Config required | Sleeps on idle | Free tier | Starting price |
|---|---|---|---|---|---|
| **Kuberns** | Yes | Procfile only | No | Yes (free credits) | $7/mo |
| Render | Yes | Build and start commands | Yes (15 min) | Yes | $7/mo |
| Railway | Yes | Start command | No | $5 trial credit | Pay per use |
| Fly.io | No, Dockerfile required | Dockerfile and fly.toml | No | Limited | Pay per use |
| Heroku | Yes | Procfile | No | No | $7/mo |
For LangChain apps handling real user requests, sleeping on idle is a serious problem. A cold start mid-conversation breaks the user experience. Kuberns does not sleep on idle and uses AI-driven auto-scaling to handle traffic spikes without over-provisioning.
For a broader comparison, see the [best PaaS providers in 2026](https://kuberns.com/blogs/best-paas-providers-in-2026-compared-found-an-ai-powered-paas/).
## Common LangChain Deployment Issues and Fixes
**App crashes immediately after deploy**
The most common cause is a missing environment variable. If `os.environ["OPENAI_API_KEY"]` raises a `KeyError`, the key was not added before deployment. Go to the Environment section in the Kuberns dashboard, add it, and redeploy.
**Requests timing out**
Your LangChain chain is taking longer than expected. Switch to streaming responses so the connection stays open during generation, or increase the `timeout_keep_alive` setting in your uvicorn config.
**Dependencies fail to install**
A package in `requirements.txt` conflicts with the Python version on the platform. Add a `runtime.txt` file at the root of your project specifying the exact Python version you used locally (for example, `python-3.12.0`).
**High memory usage**
LangChain loads embedding indexes into memory when using local vector stores. If you hit memory limits, switch to an external managed vector store like Pinecone or Supabase with pgvector.
## Why Developers Deploy LangChain Apps on Kuberns
Provisioning a server for a Python AI app the traditional way means picking an instance, installing Python, configuring a process manager, setting up a reverse proxy, handling SSL, and managing all of it when something breaks. For most LangChain apps, that is not work you should be doing.
[Kuberns](https://kuberns.com) handles all of that. Push your code and the agentic AI takes care of the rest: runtime detection, dependency installation, SSL, auto-scaling, and CI/CD on every Git push. You stay focused on your LangChain logic, not the infrastructure around it.
If you are building a complete AI product, the guide on [deploying a full stack app with AI](https://kuberns.com/blogs/deploy-full-stack-app-with-ai/) covers connecting your Python backend to a frontend on the same platform. For teams looking at the bigger picture, [the AI development stack in 2026](https://kuberns.com/blogs/the-ai-development-stack-in-2026-how-developers-build-products-end-to-end/) covers how modern AI apps are built and shipped end to end.
[Deploy your LangChain app free on Kuberns](https://dashboard.kuberns.com)
---
## Frequently Asked Questions
### Q: What is the easiest way to deploy a LangChain app in 2026?
Wrap your chain or agent in a FastAPI server, push to GitHub, and deploy on [Kuberns](https://kuberns.com). The platform detects your Python stack automatically, installs dependencies from `requirements.txt`, and gets your app live with HTTPS in under 5 minutes. No Docker or server config required.
### Q: Do I need Docker to deploy a LangChain app?
No. Kuberns detects your Python runtime and reads your start command from a Procfile. You do not need a Dockerfile, a container registry, or any build configuration files.
### Q: How do I store API keys like OPENAI_API_KEY in production?
Add them as environment variables in the Kuberns dashboard before deploying. Never hardcode API keys in your source code. Kuberns encrypts all variables at rest and injects them securely at runtime without exposing them in logs.
### Q: Can I deploy a LangChain RAG app on Kuberns?
Yes. LangChain RAG apps are standard Python applications. Wrap your retrieval chain in a FastAPI endpoint, add your vector database connection string as an environment variable, and deploy the same way as any Python app.
### Q: Does Kuberns support LangGraph deployments?
Yes. LangGraph apps are Python applications. As long as your app exposes an HTTP server reading `PORT` from the environment, Kuberns will deploy it without any extra configuration.
### Q: How long does it take to deploy a LangChain app on Kuberns?
Under 5 minutes for the first deployment. Subsequent auto-deploys triggered by a Git push typically complete in 60 to 90 seconds.
### Q: What Python version does Kuberns support?
Kuberns supports Python 3.9 and above. Specify the exact version you need in a `runtime.txt` file at the root of your project.
---
- [More AI & DevOps articles](https://kuberns.com/blogs/category/ai-devops/1/)
- [All articles](https://kuberns.com/blogs/)