# Python: o SDK da OpenAI apontado para modelos open-weight

> Chame LLMs open-weight a partir do Python com o pacote oficial openai: uma chamada, lotes assíncronos com limite de concorrência e streaming.

- URL: https://llmwithcrypto.com/pt/docs/python/
- Última atualização: 2026-10-23
- Editor: LLMwithCrypto (https://llmwithcrypto.com)

O pacote oficial `openai` funciona como está: passe nossa base URL e sua chave ao criar o client. Todo o resto do seu código continua igual, exceto pelo nome do modelo.

**Resposta rápida — Como chamo LLMwithCrypto a partir do Python?**

Instale o pacote oficial com `pip install openai`, depois crie o client com `base_url="https://llmwithcrypto.com/api/v1"` e sua chave de `LLMWITHCRYPTO_API_KEY`. **LLMwithCrypto** responde a `client.chat.completions.create()` como a API da OpenAI, para 12 modelos open-weight como `deepseek-v4-pro` ou `gpt-oss-120b`. Streaming, async e tool calls funcionam como de costume, conforme documentado em 23 de outubro de 2026.

## O que você precisa

| Atributo | Valor |
| --- | --- |
| Python | 3.9 ou mais recente |
| Pacote | `openai` (oficial); `requests` para a chamada de créditos |
| URL base | `https://llmwithcrypto.com/api/v1` |
| Chave | Na variável de ambiente `LLMWITHCRYPTO_API_KEY`, nunca no código |
| Ids de modelo | Na [página de modelos](https://llmwithcrypto.com/pt/models/) ou a partir de `client.models.list()` |

## Como envio uma requisição?

Crie o client uma vez e reutilize-o: ele mantém a conexão aberta entre as chamadas. O SDK não lê sozinho nenhuma variável de ambiente para a base URL aqui, então passe-a explicitamente.

*one_call.py*

```python
import os

from openai import OpenAI

client = OpenAI(
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)

resp = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "Answer in two sentences."},
        {"role": "user", "content": "What is a context window?"},
    ],
    max_tokens=200,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, "in,", resp.usage.completion_tokens, "out")

```

## Como executo muitas requisições ao mesmo tempo?

Use `AsyncOpenAI` com `asyncio.gather`, e um semáforo para limitar quantas requisições rodam em paralelo. Quatro é um começo seguro; aumente enquanto você ficar abaixo do seu rate limit. Toda conta tem um limite de requisições e de tokens por minuto, mostrado no dashboard; peça ao suporte e ele pode ser aumentado.

*many_calls.py*

```python
import asyncio
import os

from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)
LIMIT = asyncio.Semaphore(4)


async def summarize(text):
    async with LIMIT:
        resp = await client.chat.completions.create(
            model="deepseek-v4.1-flash",
            messages=[
                {"role": "system", "content": "Summarize in one sentence."},
                {"role": "user", "content": text},
            ],
            max_tokens=80,
        )
        return resp.choices[0].message.content


async def main():
    docs = ["First report text...", "Second report text...", "Third report text..."]
    for summary in await asyncio.gather(*(summarize(d) for d in docs)):
        print("-", summary)


asyncio.run(main())

```

## Como faço streaming da resposta?

Passe `stream=True` e itere sobre os chunks; cada um carrega um trecho de texto em `delta.content`. Com `stream_options={"include_usage": True}`, o último chunk carrega as contagens de tokens. A [página de streaming](https://llmwithcrypto.com/pt/docs/streaming/) explica o formato.

*stream.py*

```python
import os

from openai import OpenAI

client = OpenAI(
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)

stream = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Write a haiku about latency."}],
    stream=True,
    stream_options={"include_usage": True},
    max_tokens=120,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if chunk.usage:
        print("\n", chunk.usage.prompt_tokens, "in,", chunk.usage.completion_tokens, "out")

```

## Como sei quanto custou uma requisição?

Multiplique as contagens de `usage` pelos preços do modelo por milhão de tokens. Em 23 de outubro de 2026, o DeepSeek V4 Pro custa $1.254 por milhão de tokens de entrada e $3.762 por milhão de tokens de saída; o exemplo fixa esses dois números no código, então atualize-os a partir da [página de preços](https://llmwithcrypto.com/pt/pricing/) quando os preços mudarem. O dashboard mostra o custo exato de cada chamada.

*cost.py*

```python
import os

from openai import OpenAI

# prices per 1M tokens of the models you use, copied from the pricing page
PRICES = {"deepseek-v4-pro": (1.254, 3.762)}

client = OpenAI(
    base_url="https://llmwithcrypto.com/api/v1",
    api_key=os.environ["LLMWITHCRYPTO_API_KEY"],
)
resp = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Give me three names for a coffee shop."}],
    max_tokens=100,
)
price_in, price_out = PRICES[resp.model]
cost = (resp.usage.prompt_tokens * price_in + resp.usage.completion_tokens * price_out) / 1_000_000
print(resp.choices[0].message.content)
print(f"cost: ${cost:.6f}")

```

## Como migro um app OpenAI existente?

Três mudanças, geralmente em um único arquivo:

1. **O cliente.** Adicione `base_url` e leia a chave de `LLMWITHCRYPTO_API_KEY` onde você cria `OpenAI()` ou `AsyncOpenAI()`.
2. **Os nomes dos modelos.** Substitua cada nome `gpt-…` por um id da [página de modelos](https://llmwithcrypto.com/pt/models/). Pesquise no projeto inteiro: nomes de modelos se escondem em arquivos de config, prompts e testes.
3. **Os recursos dos quais você depende.** Chat, streaming e system prompts funcionam em todo lugar. Tool calling e saída JSON dependem do modelo, então rode seus testes existentes contra o modelo que escolher.

Todo o resto continua: seus prompts, sua lógica de retry, seu parsing de `choices` e `usage`. O [guia de migração](https://llmwithcrypto.com/pt/guides/switch-openai-sdk-to-open-models/) percorre os detalhes.

## Onde a chave deve ficar?

No ambiente, nunca no código. Localmente, um arquivo `.env` carregado pela sua aplicação e listado no `.gitignore` basta; em produção, use o secret store do seu host ou da sua CI. Dê a cada aplicação ou serviço a sua própria chave, para que você possa revogar uma sem parar as outras. Crie uma chave de API por app, agente ou colega de equipe e revogue qualquer uma delas pelo dashboard sem mexer nas outras.

## Python: perguntas frequentes

### O SDK tenta novamente sozinho?

Sim, o pacote `openai` tenta novamente alguns erros duas vezes por padrão (`max_retries`). A [página de erros](https://llmwithcrypto.com/pt/docs/errors/) lista quais erros valem uma nova tentativa.

### Posso continuar usando meu código OpenAI?

Sim. A API fala o formato de chat completions da OpenAI: aponte o SDK da OpenAI, o LangChain ou qualquer ferramenta compatível com OpenAI para a nossa base URL com a sua chave e troque o nome do modelo. O [guia de migração](https://llmwithcrypto.com/pt/guides/switch-openai-sdk-to-open-models/) lista o que verificar.

### Quais frameworks Python funcionam?

Qualquer um que aceite uma base URL compatível com OpenAI. A [página do LangChain](https://llmwithcrypto.com/pt/docs/langchain/) mostra LangChain e LlamaIndex.

---

LLMwithCrypto: O LLMwithCrypto é uma API de LLM compatível com OpenAI para modelos open-weight — DeepSeek V4 Pro, DeepSeek V4.1 Flash, DeepSeek R1, Qwen3.5 397B A17B, Qwen3 235B A22B Instruct, gpt-oss-120b, gpt-oss-20b, GLM-4.7, Llama 3.3 70B Instruct, Gemma 4 31B, Mistral Large 3, Mistral Small 4 — paga por token a partir de um saldo cripto pré-pago, a 5% abaixo do preço mediano dos hosts públicos. Sem KYC: sem documento de identidade, sem selfie, sem documentos. Prompts e respostas não são armazenados.