# Python: OpenAI SDK skierowany na modele open-weight

> Wywołuj modele open-weight z Pythona przez pakiet openai: jedno wywołanie, asynchroniczne batche z limitem współbieżności, streamowanie i koszt zapytania.

- URL: https://llmwithcrypto.com/pl/docs/python/
- Ostatnia aktualizacja: 2026-10-23
- Wydawca: LLMwithCrypto (https://llmwithcrypto.com)

Oficjalny pakiet `openai` działa bez zmian: przy tworzeniu klienta przekaż nasz bazowy URL i swój klucz. Reszta kodu zostaje taka sama, poza nazwą modelu.

**Krótka odpowiedź — Jak wywołać LLMwithCrypto z Pythona?**

Zainstaluj oficjalny pakiet przez `pip install openai`, potem utwórz klienta z `base_url="https://llmwithcrypto.com/api/v1"` i swoim kluczem z `LLMWITHCRYPTO_API_KEY`. **LLMwithCrypto** odpowiada jak OpenAI API na `client.chat.completions.create()`, dla 12 modeli open-weight, takich jak `deepseek-v4-pro` czy `gpt-oss-120b`. Streamowanie, async i tool calls działają jak zwykle, zgodnie z dokumentacją z 23 października 2026.

## Czego potrzebujesz

| Atrybut | Wartość |
| --- | --- |
| Python | 3.9 lub nowszy |
| Pakiet | `openai` (oficjalny); `requests` do wywołania kredytów |
| Base URL | `https://llmwithcrypto.com/api/v1` |
| Klucz | W zmiennej środowiskowej `LLMWITHCRYPTO_API_KEY`, nigdy w kodzie |
| Id modeli | Na [stronie modeli](https://llmwithcrypto.com/pl/models/) lub z `client.models.list()` |

## Jak wysłać jedno zapytanie?

Utwórz klienta raz i używaj go ponownie: utrzymuje połączenie otwarte między wywołaniami. SDK samo nie czyta tu żadnej zmiennej środowiskowej dla bazowego URL, więc przekaż go jawnie.

*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")

```

## Jak uruchomić wiele zapytań naraz?

Użyj `AsyncOpenAI` z `asyncio.gather` i semafora, aby ograniczyć liczbę zapytań wykonywanych równolegle. Cztery to bezpieczny start; zwiększaj, dopóki pozostajesz poniżej swojego rate limit. Każde konto ma limit zapytań i tokenów na minutę, widoczny w dashboardzie; poproś support, a można go podnieść.

*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())

```

## Jak streamować odpowiedź?

Przekaż `stream=True` i iteruj po chunkach; każdy z nich zawiera fragment tekstu w `delta.content`. W przypadku `stream_options={"include_usage": True}` ostatni chunk zawiera liczby tokenów. [Strona o streamingu](https://llmwithcrypto.com/pl/docs/streaming/) wyjaśnia format.

*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")

```

## Skąd mam wiedzieć, ile kosztowało zapytanie?

Pomnóż liczby z `usage` przez ceny modelu za milion tokenów. Na dzień 23 października 2026 DeepSeek V4 Pro kosztuje $1.254 za milion tokenów wejściowych i $3.762 za milion tokenów wyjściowych; przykład ma te dwie liczby zapisane na sztywno, więc zaktualizuj je ze [strony cennika](https://llmwithcrypto.com/pl/pricing/), gdy ceny się zmienią. Dashboard pokazuje dokładny koszt każdego wywołania.

*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}")

```

## Jak przenieść istniejącą aplikację OpenAI?

Trzy zmiany, zwykle w jednym pliku:

1. **Klient.** Dodaj `base_url` i odczytaj klucz z `LLMWITHCRYPTO_API_KEY` tam, gdzie tworzysz `OpenAI()` lub `AsyncOpenAI()`.
2. **Nazwy modeli.** Zastąp każdą nazwę `gpt-…` identyfikatorem ze [strony modeli](https://llmwithcrypto.com/pl/models/). Przeszukaj cały projekt: nazwy modeli ukrywają się w plikach konfiguracyjnych, promptach i testach.
3. **Funkcje, na których polegasz.** Chat, streaming i prompty systemowe działają wszędzie. Tool calling i wyjście JSON zależą od modelu, więc uruchom swoje istniejące testy na wybranym modelu.

Wszystko inne zostaje: Twoje prompty, Twoja logika ponawiania, Twoje parsowanie `choices` i `usage`. [Przewodnik po przełączaniu](https://llmwithcrypto.com/pl/guides/switch-openai-sdk-to-open-models/) omawia szczegóły.

## Gdzie powinien znajdować się klucz?

W środowisku, nigdy w kodzie. Lokalnie wystarczy plik `.env` ładowany przez Twoją aplikację i wymieniony w `.gitignore`; w produkcji użyj magazynu sekretów swojego hosta lub CI. Daj każdej aplikacji lub usłudze własny klucz, aby móc unieważnić jeden bez zatrzymywania pozostałych. Twórz jeden klucz API na aplikację, agenta lub członka zespołu i odwołuj każdy z nich z dashboardu, nie ruszając pozostałych.

## Python: często zadawane pytania

### Czy SDK sam ponawia żądania?

Tak, pakiet `openai` domyślnie dwa razy ponawia niektóre błędy (`max_retries`). [Strona błędów](https://llmwithcrypto.com/pl/docs/errors/) wymienia, które błędy warto ponowić.

### Czy mogę nadal używać swojego kodu OpenAI?

Tak. API mówi w formacie OpenAI chat completions: skieruj OpenAI SDK, LangChain lub dowolne narzędzie zgodne z OpenAI na nasz base URL ze swoim kluczem i zmień nazwę modelu. [Przewodnik po przełączaniu](https://llmwithcrypto.com/pl/guides/switch-openai-sdk-to-open-models/) wymienia, co sprawdzić.

### Które frameworki Python działają?

Wszystko, co akceptuje base URL zgodny z OpenAI. [Strona LangChain](https://llmwithcrypto.com/pl/docs/langchain/) pokazuje LangChain i LlamaIndex.

---

LLMwithCrypto: LLMwithCrypto to zgodne z OpenAI API LLM dla modeli z otwartymi wagami — 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 — płatne za token z przedpłaconego salda kryptowalutowego, o 5% poniżej mediany ceny publicznych hostów. Bez KYC: bez dowodu, bez selfie, bez dokumentów. Prompty i odpowiedzi nie są przechowywane.