1. Visão geral do LangServe

LangServe é uma biblioteca que ajuda os desenvolvedores a executar programas e cadeias de LangChain como APIs REST. Ela integra o FastAPI e utiliza o pydantic para validação de dados.

2. Funcionalidades

LangServe possui as seguintes funcionalidades:

  • Inferir automaticamente os modos de entrada e saída a partir de objetos LangChain e realizar validação para cada chamada de API, fornecendo mensagens de erro detalhadas
  • Página de documentação da API contendo JSONSchema e Swagger
  • Eficientes endpoints /invoke/, /batch/ e /stream/ que suportam muitas requisições simultâneas em um único servidor
  • Endpoint /stream_log/ para transmitir todos (ou parte) dos passos intermediários da cadeia/agente
  • Nova funcionalidade a partir da versão 0.0.40, suporta astream_events para facilitar a transmissão sem analisar a saída de stream_log
  • Página /playground/ com saída de transmissão e passos intermediários
  • Rastreamento embutido opcional para o LangSmith, apenas adicionando sua chave de API
  • Construído com bibliotecas Python de código aberto comprovadas em batalha, como FastAPI, Pydantic, uvloop e asyncio
  • Invocar o servidor LangServe usando um SDK de cliente, como chamar um Runnable em execução localmente (ou chamar diretamente a API HTTP)
  • LangServe Hub

3. Limitações

  • Callbacks do cliente para eventos originados do servidor ainda não são suportados
  • A documentação do OpenAPI não é gerada ao usar o Pydantic V2. O FastAPI não suporta namespaces mistos pydantic v1 e v2. Consulte a seção abaixo para mais detalhes.

4. Instalação

Você pode instalar o LangServe usando o seguinte comando:

pip install "langserve[all]"

Ou instalar o código do cliente usando pip install "langserve[client]", e o código do servidor usando pip install "langserve[server]".

4. Aplicação de Exemplo

Abaixo, demonstramos como publicar modelos, cadeias e agentes definidos em LangChain como APIs REST para outras aplicações chamarem. Se você estiver familiarizado com o FastAPI, é simples, basta usar a classe utilitária fornecida pelo langserve para registrar rotas do FastAPI.

O exemplo a seguir implementa um modelo de chat da OpenAI, um modelo de chat Anthropic e uma cadeia que utiliza o modelo Anthropic para contar piadas sobre tópicos específicos.

Aqui está o código de exemplo:

from fastapi import FastAPI
from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatAnthropic, ChatOpenAI
from langserve import add_routes

app = FastAPI(
    title="Servidor LangChain",
    version="1.0",
    description="Servidor de API simples usando a interface Runnable do LangChain",
)

add_routes(
    app,
    ChatOpenAI(),
    path="/openai",
)

add_routes(
    app,
    ChatAnthropic(),
    path="/anthropic",
)

modelo = ChatAnthropic()
prompt = ChatPromptTemplate.from_template("conte-me uma piada sobre {tópico}")
add_routes(
    app,
    prompt | modelo,
    path="/piada",
)

if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="localhost", port=8000)

Se você pretende chamar os endpoints de um navegador, também precisa configurar cabeçalhos CORS. Você pode fazer isso usando o middleware incorporado no FastAPI:

from fastapi.middleware.cors import CORSMiddleware

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
    expose_headers=["*"],
)

5. Documentação

Após executar o exemplo acima, o LangServe gera automaticamente a documentação da API para todas as rotas registradas. Você pode verificar a documentação do OpenAPI gerada no seguinte endereço:

http://localhost:8000/docs

Certifique-se de acrescentar o sufixo /docs.

⚠️ Se estiver usando o pydantic v2, a documentação não será gerada para invoke, batch, stream e stream_log. É recomendado usar a versão pydantic v1.

6. Introdução às Rotas da API

Abaixo está uma introdução às interfaces da API geradas pelo LangServe após registrar uma rota da API.

Por exemplo, considere o seguinte código:

add_routes(
    app,
    runnable,
    path="/my_runnable",
)

O LangServe irá gerar as seguintes interfaces:

  • POST /my_runnable/invoke - Interface para invocação do modelo
  • POST /my_runnable/batch - Interface para invocação em lote do modelo
  • POST /my_runnable/stream - Interface para invocação de modelo em streaming
  • POST /my_runnable/stream_log - Interface para invocação de modelo em streaming com saída de log
  • POST /my_runnable/astream_events - Invocação de modelo em streaming assíncrono com saída de eventos
  • GET /my_runnable/input_schema - Descrição dos parâmetros da interface para invocação do modelo
  • GET /my_runnable/output_schema - Descrição dos parâmetros da interface para a saída do modelo
  • GET /my_runnable/config_schema - Descrição da configuração do modelo

7. Playground

O LangServe fornece uma página de depuração de interface de usuário para cada rota registrada, facilitando a depuração dos serviços Chain, Agent e outros serviços LangChain que definirmos.

Você pode acessar o exemplo de Playground no seguinte formato: visite /my_runnable/playground/.