Home/Inference & Serving/langchain-serve
langchain-serve logo

langchain-serve

archived
jina-ai/langchain-serve

⚡ Langchain apps in production using Jina & FastAPI

GraphCanon updated 2w · GitHub synced 2w

1.6k stars133 forksLast push 2y Python Apache-2.0

Decision brief

A tool for deploying Langchain applications using Jina & FastAPI, supporting Kubernetes or Docker Compose with built-in secrets management.

Good fit when

  • You need to deploy Langchain apps on personal infrastructure while ensuring security through your own policies.
  • Your project requires autoscaling and secret management facilitated by JCloud's deployment options.

Avoid when

  • If deploying locally without the advantages of secure secret handling or managed scaling from Jina AI Cloud is acceptable.
  • For scenarios where you prefer a more customizable platform than what Jina AI Cloud offers in terms of pricing and instance configurations.

Observed Jul 12, 2026 · Source: enrich:decision_facts

Verify the decision

Maintenance and security

Full trust report
Maintenance
Archived (1053d since push)
As of 2w
Provenance
Not a fork · Organization account
As of 2w
Security (OSV)
No criticals
As of 1mo

Public GitHub metadata and optional OSV scans. Signals, not a guarantee. Trust methodology.

Install

pip install langchain-serve
PyPI

Similar tools

Same-category neighbours. No typed graph edges are catalogued for this tool yet.

Evidence and technical details

Sourced facts, taxonomy, compatibility claims, README excerpt, and machine-readable endpoints.

Overview

A tool for deploying Langchain applications with support for Kubernetes or Docker Compose, enabling secure secrets management.

Capability facts

Languages
python

Source: github.language+pyproject.toml · Aug 8, 2026

Categories

Compatibility

Sourced claims from the README excerpt - not unsourced marketing copy.

Python runtimePython

Source: README excerpt (regex_v1, Aug 8, 2026)

```python
Source link

Tags

README

🏠 Self-host LLM Apps with Docker Compose or Kubernetes

  • 🚀 Export your apps as Kubernetes or Docker Compose YAMLs with single command.
  • 👉 lc-serve export app --kind <kubernetes/docker-compose> --path .
  • 📦 Deploy your app on your own internal infrastructure with your own security policies.
  • 📞 Talk to us if you need all the features of Jina AI Cloud on your own infrastructure.

🗝️ Using Secrets during Deployment

You can use secrets during app deployment by passing a secrets file to deployment with the --secrets flag. The secrets file should be a .env file containing the secrets.

lcserve deploy jcloud app --secrets .env
Show details

Let's take an example of a simple app that uses OPENAI_API_KEY stored as secrets.

This app directory contains the following files:

.
├── main.py             # The app
├── jcloud.yml          # JCloud deployment config file
├── README.md           # This README file
├── requirements.txt    # The requirements file for the app
└── secrets.env         # The secrets file containing the redis credentials

Note secret.env in this directory is a dummy file. You should replace it with your own secrets after creating a Redis instance. (For example with Upstash), such as:

OPENAI_API_KEY=sk-xxx

main.py will look like:


---

## 💰 Pricing

Applications hosted on JCloud are priced in two categories:

**Base credits**

- Base credits are charged to ensure high availability for your application by maintaining at least one instance running continuously, ready to handle incoming requests. If you wish to stop the serving application, you can either remove the app completely or put it on pause, the latter allows you to resume the app serving based on persisted configurations (refer to [`lc-serve` CLI section](#-lc-serve-cli) for more information). Both options will halt the consumption of credits.
- Actual credits charged for base credits are calculated based on the [instance type as defined by Jina AI Cloud](https://docs.jina.ai/concepts/jcloud/configuration/#cpu-tiers).
- By default, instance type `C3` is used with a minimum of 1 instance and [Amazon EFS](https://aws.amazon.com/efs/) disk of size 1G, which means that if your application is served on JCloud, you will be charged ~10 credits per hour.
- You can change the instance type and the minimum number of instances by providing a YAML configuration file using the `--config` option. For example, if you want to use instance type `C4` with a minimum of 0 replicas, and 2G EFS disk, you can provide the following configuration file:
  ```yaml
  instance: C4
  autoscale_min: 0
  disk_size: 2G

Serving credits

  • Serving credits are charged when your application is actively serving incoming requests.
  • Actual credits charged for serving credits are calculated based on the credits for the instance type multiplied by the duration for which your application serves requests.
  • You are charged for each second your application is serving requests.

Total credits charged = Base credits + Serving credits. (Jina AI Cloud defines each credit as €0.005)


JCloud deployment failed at pushing image to Jina Hubble, what should I do?

Expand

Please use --verbose and retry to get more information. If you are operating on computer with arm64 arch, please retry with --platform linux/amd64 so the image can be built correctly.

For agents

This page has a .md twin and JSON over the API.

Was this helpful?

Anonymous feedback helps us improve pages and translations.