Blog

LangWatch: O Que É, Como Instalar e Usar

Ashley Goolam

Ashley Goolam

18 julho 2025

LangWatch: O Que É, Como Instalar e Usar

Com dificuldades para avaliar e otimizar seus pipelines de modelos de linguagem grandes (LLM)? Apresentamos o LangWatch, uma plataforma revolucionária que facilita o monitoramento, a avaliação e o ajuste fino de seus fluxos de trabalho LLM personalizados. Neste guia, vamos nos aprofundar no que é o LangWatch, por que ele é incrível e como instalá-lo e usá-lo para impulsionar seus projetos de IA. Vamos configurar um chatbot simples, integrar o LangWatch e testá-lo com uma pergunta de exemplo — tudo isso de forma fácil de seguir. Vamos começar!

💡
Quer uma ótima ferramenta de Teste de API que gera documentação de API bonita?

Quer uma plataforma integrada e completa para sua Equipe de Desenvolvedores trabalhar com produtividade máxima?

Apidog atende a todas as suas demandas e substitui o Postman por um preço muito mais acessível!
button

O Que É o LangWatch e Por Que Você Deveria Se Importar?

O LangWatch é a sua plataforma ideal para resolver o complexo problema da avaliação de LLMs. Ao contrário dos modelos tradicionais com métricas padrão como F1-score para classificação, BLEU para tradução ou ROUGE para sumarização, os LLMs generativos são não-determinísticos e difíceis de definir. Além disso, cada empresa tem seus próprios dados, modelos ajustados e pipelines personalizados, tornando a avaliação uma dor de cabeça. É aí que o LangWatch se destaca!

O LangWatch permite que você:

Seja você está construindo um chatbot, uma ferramenta de tradução ou um aplicativo de IA personalizado, o LangWatch ajuda a garantir que seu LLM entregue resultados de primeira linha. Pronto para vê-lo em ação? Vamos instalar e usar o LangWatch!

site oficial do langwatch

Guia Passo a Passo para Instalar e Usar o LangWatch

Pré-requisitos

Antes de começarmos, você precisará:

Passo 1: Cadastre-se no LangWatch

Criar uma Conta:

Obter Sua Chave de API:

criar uma conta com langwatch

Passo 2: Configurar um Projeto Python com LangWatch

Vamos criar um projeto Python e integrar o LangWatch para rastrear um chatbot simples.

  1. Criar uma Pasta de Projeto:
mkdir langwatch-demo
cd langwatch-demo

2. Configurar um Ambiente Virtual:

python -m venv venv
source venv/bin/activate  # No Windows: venv\Scripts\activate

3. Instalar LangWatch e Dependências:

pip install langwatch chainlit openai

4. Criar o Código do Chatbot:

import os
import chainlit as cl
import asyncio
from openai import AsyncClient

openai_client = AsyncClient()  # Assumes OPENAI_API_KEY is set in environment
model_name = "gpt-4o-mini"
settings = {
    "temperature": 0.3,
    "max_tokens": 500,
    "top_p": 1,
    "frequency_penalty": 0,
    "presence_penalty": 0,
}

@cl.on_chat_start
async def start():
    cl.user_session.set(
        "message_history",
        [
            {
                "role": "system",
                "content": "You are a helpful assistant that only reply in short tweet-like responses, using lots of emojis."
            }
        ]
    )

async def answer_as(name: str):
    message_history = cl.user_session.get("message_history")
    msg = cl.Message(author=name, content="")
    stream = await openai_client.chat.completions.create(
        model=model_name,
        messages=message_history + [{"role": "user", "content": f"speak as {name}"}],
        stream=True,
        **settings,
    )
    async for part in stream:
        if token := part.choices[0].delta.content or "":
            await msg.stream_token(token)
    message_history.append({"role": "assistant", "content": msg.content})
    await msg.send()

@cl.on_message
async def main(message: cl.Message):
    message_history = cl.user_session.get("message_history")
    message_history.append({"role": "user", "content": message.content})
    await asyncio.gather(answer_as("AI Bites"))

5. Definir Sua Chave de API OpenAI:

export OPENAI_API_KEY="your-openai-api-key"  # No Windows: set OPENAI_API_KEY=your-openai-api-key

6. Executar o Chatbot:

chainlit run app.py
testar aplicativo chainlit

Passo 3: Integrar o LangWatch para Rastreamento

Agora, vamos adicionar o LangWatch para rastrear as mensagens do chatbot.

  1. Modificar app.py para o LangWatch:
import os
import chainlit as cl
import asyncio
import langwatch
from openai import AsyncClient

openai_client = AsyncClient()
model_name = "gpt-4o-mini"
settings = {
    "temperature": 0.3,
    "max_tokens": 500,
    "top_p": 1,
    "frequency_penalty": 0,
    "presence_penalty": 0,
}

@cl.on_chat_start
async def start():
    cl.user_session.set(
        "message_history",
        [
            {
                "role": "system",
                "content": "You are a helpful assistant that only reply in short tweet-like responses, using lots of emojis."
            }
        ]
    )

async def answer_as(name: str):
    message_history = cl.user_session.get("message_history")
    msg = cl.Message(author=name, content="")
    stream = await openai_client.chat.completions.create(
        model=model_name,
        messages=message_history + [{"role": "user", "content": f"speak as {name}"}],
        stream=True,
        **settings,
    )
    async for part in stream:
        if token := part.choices[0].delta.content or "":
            await msg.stream_token(token)
    message_history.append({"role": "assistant", "content": msg.content})
    await msg.send()

@cl.on_message
@langwatch.trace()
async def main(message: cl.Message):
    message_history = cl.user_session.get("message_history")
    message_history.append({"role": "user", "content": message.content})
    await asyncio.gather(answer_as("AI Bites"))

2. Testar a Integração:

chainlit run app.py
mensagem de rastreamento langwatch

Passo 4: Configurar um Fluxo de Trabalho para Avaliar Seu Chatbot

Vamos criar um conjunto de dados e um avaliador no LangWatch para avaliar o desempenho do chatbot.

  1. Criar um Conjunto de Dados:
Pergunta Resposta Esperada
Qual é a palavra francesa para hoje? Aujourd’hui

2. Configurar um Avaliador:

estrutura do fluxo de trabalho

3. Executar o Avaliador:

executar a correspondência de resposta do llm

Você deve ver algo como:

resultado pop-up

4. Avaliar o Fluxo de Trabalho:

avaliar todo o fluxo de trabalho do llm

Passo 5: Otimizar Seu Fluxo de Trabalho

Uma vez concluída sua avaliação, vamos otimizar o desempenho do chatbot.

1. Executar Otimização:

iniciar o processo de otimização do llm

2. Verificar Melhorias:

resultados da otimização do fluxo de trabalho

Passo 6: Configuração Opcional do LangWatch Local

Quer executar o LangWatch localmente para testes com dados sensíveis? Siga estes passos:

  1. Clonar o Repositório:
git clone https://github.com/langwatch/langwatch.git
cd langwatch

2. Configurar o Ambiente:

cp langwatch/.env.example langwatch/.env

3. Executar com Docker:

docker compose up -d --wait --build

4. Acessar o Painel:

Nota: A configuração do Docker é apenas para testes e não é escalável para produção. Para produção, use o LangWatch Cloud ou Enterprise On-Premises.

Por Que Usar o LangWatch?

O LangWatch resolve o quebra-cabeça da avaliação de LLMs, fornecendo uma plataforma unificada para monitorar, avaliar e otimizar seus pipelines de IA. Seja ajustando prompts, analisando o desempenho ou garantindo que seu chatbot dê respostas precisas (como “Aujourd’hui” para “hoje” em francês), o LangWatch torna tudo mais fácil. Sua integração com Python e ferramentas como Chainlit e OpenAI significa que você pode começar a rastrear e melhorar seus aplicativos LLM em minutos.

Por exemplo, nosso chatbot de demonstração agora responde em explosões semelhantes a tweets com emojis, e o LangWatch ajuda a garantir que ele seja preciso e otimizado. Quer escalar? Adicione mais perguntas ao seu conjunto de dados ou experimente diferentes modelos LLM no avaliador.

Conclusão

Aí está! Você aprendeu o que é o LangWatch, como instalá-lo e como usá-lo para monitorar e otimizar um chatbot. Desde a configuração de um projeto Python até o rastreamento de mensagens e a avaliação de desempenho com um conjunto de dados, o LangWatch capacita você a assumir o controle de seus pipelines LLM. Nossa pergunta de teste — “Qual é a palavra francesa para hoje?” — mostrou como é fácil rastrear e melhorar as respostas da IA.

Pronto para elevar o nível do seu jogo de IA? Acesse app.langwatch.ai, cadastre-se e comece a experimentar o LangWatch hoje mesmo.

💡
Quer uma ótima ferramenta de Teste de API que gera documentação de API bonita?

Quer uma plataforma integrada e completa para sua Equipe de Desenvolvedores trabalhar com produtividade máxima?

Apidog atende a todas as suas demandas e substitui o Postman por um preço muito mais acessível!
button

Pratique o design de API no Apidog

Descubra uma forma mais fácil de construir e usar APIs

Cadastre-se gratuitamenteBaixar