Wniosek i użycie OpenAI Chat Completion API

OpenAI ChatGPT to bardzo potężny system AI do rozmów, który potrafi w ciągu kilku sekund wygenerować płynne i naturalne odpowiedzi na wprowadzone zapytania. ChatGPT wyróżnia się w branży dzięki swoim doskonałym zdolnościom rozumienia i generowania języka, a obecnie jest szeroko stosowany w różnych branżach i dziedzinach, a jego wpływ staje się coraz bardziej znaczący. Niezależnie od tego, czy chodzi o codzienne rozmowy, kreatywne pisanie, czy profesjonalne doradztwo i programowanie, ChatGPT może zapewnić zdumiewające wsparcie inteligentne, znacznie zwiększając wydajność i kreatywność ludzi. Dokument ten głównie opisuje proces korzystania z OpenAI Chat Completion API, dzięki któremu możemy łatwo korzystać z funkcji rozmowy oficjalnego OpenAI ChatGPT.

Proces aplikacji

Aby korzystać z OpenAI Chat Completion API, najpierw można przejść na stronę OpenAI Chat Completion API i kliknąć przycisk „Acquire”, aby uzyskać potrzebne poświadczenia do żądania:

Jeśli nie jesteś zalogowany lub zarejestrowany, automatycznie zostaniesz przekierowany na stronę logowania, aby zarejestrować się i zalogować, a po zalogowaniu lub rejestracji automatycznie wrócisz na bieżącą stronę. Podczas pierwszej aplikacji otrzymasz darmowy limit, który pozwala na bezpłatne korzystanie z tego API.

Podstawowe użycie

Następnie możesz wypełnić odpowiednie treści na interfejsie, jak pokazano na obrazku:

Podczas pierwszego korzystania z tego interfejsu musimy wypełnić co najmniej trzy pola: jedno to authorization, które można wybrać bezpośrednio z rozwijanej listy. Kolejnym parametrem jest model, który oznacza wybór modelu OpenAI ChatGPT z oficjalnej strony, mamy tutaj głównie 20 modeli, szczegóły można zobaczyć w dostarczonych modelach. Ostatnim parametrem jest messages, który jest tablicą naszych zapytań, oznaczającą możliwość przesyłania wielu zapytań jednocześnie, gdzie każde zapytanie zawiera role i content, przy czym role oznacza rolę pytającego, a my oferujemy trzy tożsamości: user, assistant, system. Drugim content jest konkretna treść naszego zapytania. Możesz również zauważyć, że po prawej stronie znajduje się odpowiedni kod do wywołania, który możesz skopiować i uruchomić, lub możesz bezpośrednio kliknąć przycisk „Try”, aby przetestować. Często używane opcjonalne parametry:

max_tokens: ogranicza maksymalną liczbę tokenów w pojedynczej odpowiedzi.
temperature: generuje losowość, w zakresie od 0 do 2, im wyższa wartość, tym bardziej rozproszone odpowiedzi.
n: ile kandydatów odpowiedzi generować jednocześnie.
response_format: ustawienia formatu odpowiedzi.

Po wywołaniu zauważamy, że wynik zwrotny wygląda następująco:

{
  "id": "chatcmpl-Cmd6uwSxN75F4PAdQSFEO8f2QPs4E",
  "object": "chat.completion",
  "created": 1765706120,
  "model": "gpt-5.2",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! What can I help you with today?",
        "refusal": null,
        "annotations": []
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 7,
    "completion_tokens": 13,
    "total_tokens": 20,
    "prompt_tokens_details": {
      "cached_tokens": 0,
      "audio_tokens": 0
    },
    "completion_tokens_details": {
      "reasoning_tokens": 0,
      "audio_tokens": 0,
      "accepted_prediction_tokens": 0,
      "rejected_prediction_tokens": 0
    }
  },
  "service_tier": "default",
  "system_fingerprint": null
}

Wynik zwrotny zawiera wiele pól, które są opisane poniżej:

id, identyfikator generowanego zadania rozmowy, używany do unikalnej identyfikacji tego zadania.
model, wybrany model OpenAI ChatGPT.
choices, informacje o odpowiedziach ChatGPT na zapytania.
usage: statystyki dotyczące tokenów dla tej sesji pytań i odpowiedzi.

Wśród nich choices zawiera informacje o odpowiedziach ChatGPT, a w nim choices to odpowiedzi ChatGPT, co można zobaczyć na obrazku.

Można zauważyć, że pole content w choices zawiera konkretną treść odpowiedzi ChatGPT.

Odpowiedzi strumieniowe

Ten interfejs obsługuje również odpowiedzi strumieniowe, co jest bardzo przydatne w integracji z stronami internetowymi, umożliwiając wyświetlanie efektu literowego. Aby uzyskać odpowiedzi strumieniowe, można zmienić parametr stream w nagłówku żądania na true. Zmiana jak na obrazku, jednak kod wywołania musi być odpowiednio zmieniony, aby obsługiwał odpowiedzi strumieniowe.

Po zmianie stream na true, API będzie zwracać odpowiednie dane JSON w wierszach, a na poziomie kodu musimy wprowadzić odpowiednie zmiany, aby uzyskać wyniki w wierszach. Przykładowy kod wywołania w Pythonie:

import requests

url = "https://api.acedata.cloud/openai/chat/completions"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "gpt-4",
    "messages": [{"role":"user","content":"hello"}],
    "stream": True
}

response = requests.post(url, json=payload, headers=headers)
print(response.text)

Efekt wyjściowy wygląda następująco:

data: {"choices": [{"delta": {"role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": "Cześć", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " tam", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": "!", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " Jak", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " mogę", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " ci", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " pomóc", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " dzisiaj", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": "?", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"role": "assistant"}, "finish_reason": "stop", "index": 0}], "created": 1721007349, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: [DONE]

Można zauważyć, że odpowiedź zawiera wiele data, a data wewnątrz choices to najnowsza treść odpowiedzi, zgodna z wcześniej przedstawioną treścią. choices to nowa treść odpowiedzi, którą można zintegrować z systemem. Zakończenie strumieniowej odpowiedzi można ocenić na podstawie zawartości data; jeśli zawartość to [DONE], oznacza to, że strumieniowa odpowiedź została zakończona. Zwracane wyniki data mają wiele pól, które są opisane poniżej:

id, identyfikator generowanego zadania rozmowy, używany do unikalnego oznaczenia tego zadania.
model, wybrany model OpenAI ChatGPT.
choices, informacje o odpowiedzi ChatGPT na zadane pytanie.

JavaScript również jest obsługiwany, na przykład kod do strumieniowego wywołania w Node.js wygląda następująco:

const options = {
  method: "post",
  headers: {
    accept: "application/json",
    authorization: "Bearer {token}",
    "content-type": "application/json",
  },
  body: JSON.stringify({
    model: "gpt-4",
    messages: [{ role: "user", content: "cześć" }],
    stream: true,
  }),
};

fetch("https://api.acedata.cloud/openai/chat/completions", options)
  .then((response) => response.json())
  .then((response) => console.log(response))
  .catch((err) => console.error(err));

Przykład kodu w Javie:

JSONObject jsonObject = new JSONObject();
jsonObject.put("model", "gpt-4");
jsonObject.put("messages", [{"role":"user","content":"cześć"}]);
jsonObject.put("stream", true);
MediaType mediaType = "application/json; charset=utf-8".toMediaType();
RequestBody body = jsonObject.toString().toRequestBody(mediaType);
Request request = new Request.Builder()
  .url("https://api.acedata.cloud/openai/chat/completions")
  .post(body)
  .addHeader("accept", "application/json")
  .addHeader("authorization", "Bearer {token}")
  .addHeader("content-type", "application/json")
  .build();

OkHttpClient client = new OkHttpClient();
Response response = client.newCall(request).execute();
System.out.print(response.body!!.string())

Inne języki można dostosować samodzielnie, zasada jest taka sama.

Wieloetapowa rozmowa

Jeśli chcesz zintegrować funkcję wieloetapowej rozmowy, musisz przesłać wiele pytań w polu messages, konkretne przykłady wielu pytań są pokazane na poniższym obrazku:

Przykład wywołania w Pythonie:

import requests

url = "https://api.acedata.cloud/openai/chat/completions"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "gpt-4",
    "messages": [{"role":"user","content":"Cześć"},{"role":"assistant","content":"Cześć! Jak mogę Ci dzisiaj pomóc?"},{"role":"user","content":"Co powiedziałem przed chwilą?"}]
}

response = requests.post(url, json=payload, headers=headers)
print(response.text)

Przez przesłanie wielu pytań, można łatwo zrealizować wieloetapową rozmowę, co może dać następującą odpowiedź:

{
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Powiedziałeś: \"Cześć.\""
      },
      "finish_reason": "stop"
    }
  ],
  "created": 1721323012,
  "id": "chatcmpl-NWZmOTA5MDlkZjBjNDRjNGEwMzRjYzA5NmM1MzQwMWY",
  "model": "gpt-4",
  "object": "chat.completion.chunk",
  "recipient": "all",
  "usage": {
    "prompt_tokens": 31,
    "completion_tokens": 6,
    "total_tokens": 37
  }
}

Można zauważyć, że informacje zawarte w choices są zgodne z podstawowym użyciem, zawierają one konkretne odpowiedzi ChatGPT na wiele rozmów, co pozwala na odpowiadanie na odpowiednie pytania na podstawie wielu treści rozmowy.

Integracja z OpenAI-Python

Usługa OpenAI Chat Completion API jest oparta na oficjalnej usłudze OpenAI, szczegóły można znaleźć w oficjalnym OpenAI-Python, w tym artykule krótko omówimy, jak korzystać z oficjalnie dostarczonej usługi.

Najpierw należy zbudować lokalne środowisko Python, ten proces można wyszukać w Google.
Zainstaluj i skonfiguruj środowisko deweloperskie, na przykład zainstaluj edytor VSCode.
Skonfiguruj zmienne środowiskowe OpenAI.

W folderze projektu utwórz plik o nazwie .env i zapisz
Zawartość pliku .env:

OPENAI_API_KEY="sk-xxx"
OPENAI_BASE_URL="https://api.acedata.cloud/openai"  # Przypominam: jeśli używasz klucza OpenAI z oficjalnej strony, nie używaj tego adresu.

Zastąp sk-xxx swoim kluczem. OPENAI_BASE_URL to adres do proxy API OpenAI.

Zainstaluj zależności projektu

pip install openai

W systemie Mac OS polecenie to:

pip3 install openai

Utwórz przykładowy plik źródłowy

Załóżmy, że stworzyliśmy przykładowy kod index.py, którego zawartość jest następująca:

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

response = client.chat.completions.create(
    messages=[
        {
            "role": "user",
            "content": "cześć",
        }
    ],
    model="gpt-4",
)

print(response.text)

Model z dostępem do internetu

Modele gpt-3.5-browsing i gpt-4-browsing różnią się od innych modeli, mogą one przeprowadzać wyszukiwanie w internecie na podstawie zadanych pytań i odpowiednio dostosowywać wyniki wyszukiwania, aby je zwrócić. W artykule tym zaprezentujemy funkcję dostępu do internetu na konkretnym przykładzie, a następnie można wypełnić odpowiednie treści w interfejsie OpenAI Chat Completion API, jak pokazano na obrazku:

Można również zauważyć, że po prawej stronie znajduje się odpowiedni kod do wywołania, który można skopiować i uruchomić, lub można bezpośrednio kliknąć przycisk „Wypróbuj”, aby przetestować.

Po wywołaniu odkrywamy, że zwrócone wyniki są następujące:

{
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Aby uzyskać najnowsze wiadomości w Chinach dzisiaj, możesz sprawdzić główne strony informacyjne, takie jak:\n\n- [BBC News China](https://www.bbc.com/news/world/asia/china)\n- [CNN China News](https://edition.cnn.com/china)\n- [Reuters China](https://www.reuters.com/news/archive/china-news)\n\nTe źródła będą miały aktualne informacje na temat bieżących wydarzeń w Chinach."
      },
      "finish_reason": "stop"
    }
  ],
  "created": 1721009347,
  "id": "chatcmpl-YzA0M2RjZDVkYThlNDkxNTkzOThmZWQ4OGMzNzdhNzA",
  "model": "gpt-4-browsing",
  "object": "chat.completion.chunk",
  "recipient": "all",
  "usage": {
    "prompt_tokens": 325,
    "completion_tokens": 82,
    "total_tokens": 407
  }
}

Można zauważyć, że informacje odpowiedzi w choices są oparte na wynikach wyszukiwania w internecie i zawierają odpowiednie linki. Informacje odpowiedzi w choices powinny być renderowane za pomocą składni markdown, aby uzyskać najlepsze doświadczenie, co również podkreśla potężną zaletę funkcji dostępu do internetu w naszym modelu.

Model wizualny

gpt-4o to wielomodalny model językowy opracowany przez OpenAI, który na podstawie GPT-4 zyskał zdolność rozumienia wizualnego. Model ten może jednocześnie przetwarzać tekst i obrazy, osiągając zrozumienie i generowanie w różnych modalnościach. Przetwarzanie tekstu w modelu gpt-4o jest zgodne z podstawowym użyciem opisanym powyżej, poniżej krótko omówimy, jak korzystać z możliwości przetwarzania obrazów tego modelu. Wykorzystanie możliwości przetwarzania obrazów w modelu gpt-4o polega głównie na dodaniu pola type do istniejącej treści content, dzięki któremu można określić, czy przesyłany jest tekst, czy obraz, co pozwala na wykorzystanie zdolności przetwarzania obrazów modelu gpt-4o. Poniżej omówimy, jak wywołać tę funkcję za pomocą Curl i Pythona.

Metoda skryptu Curl

curl -X POST 'https://api.acedata.cloud/openai/chat/completions' \
-H 'accept: application/json' \
-H 'authorization: Bearer {token}' \
-H 'content-type: application/json' \
-d '{
    "model": "gpt-4o",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "Co jest na tym obrazie?"
          },
          {
            "type": "image_url",
            "image_url": {
              "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
            }
          }
        ]
      }
    ]
  }'

Metoda skryptu Python

```python
import requests

url = "https://api.acedata.cloud/openai/chat/completions"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "gpt-4o",
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "text", "text": "Co jest na tym obrazie?"
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
                    }
                },
            ],
        }
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.text)

Można zobaczyć, że odpowiedź jest oparta na obrazie, dlatego za pomocą powyższych dwóch sposobów można łatwo wykorzystać zdolności przetwarzania tekstu i obrazu modelu gpt-4-vision. Oprócz gpt-4o, istnieje również tańszy model, zwany gpt-4o-mini. gpt-4o-mini to najnowsza generacja dużego modelu językowego opracowanego przez OpenAI, który nie tylko działa szybko, ale także jest tańszy i obsługuje multimodalność. Funkcje wizji można znaleźć w treści dotyczącej użycia modelu gpt-4o.

Model rysunkowy GPT-4o

Przykład żądania:

{
  "model": "gpt-4o-image",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Wygeneruj obraz w stylu Ghibli i dodaj kapelusz"
        },
        {
          "type": "file_url",
          "file_url": {
            "url": "https://cdn.acedata.cloud/qzx2z1.png"
          }
        }
      ]
    }
  ],
  "stream": false
}

Przykład wyniku:

{
  "id": "chatcmpl-89CXTr5EHi7WgiO3qSzWxvmqwfryP",
  "object": "chat.completion.chunk",
  "model": "gpt-4o-image",
  "created": 1744395060,
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "{\n  \"prompt\": \"Młoda kobieta z długimi czarnymi włosami w białej sukience stojąca w malowniczym otoczeniu na świeżym powietrzu. Obraz jest w stylu animacji Studio Ghibli, z miękkimi kolorami i delikatnymi detalami. Ma na sobie uroczy, stylowy kapelusz, z ciepłym i radosnym uśmiechem. Tło pokazuje bujną zieleń i spokojną atmosferę, z promieniami słońca filtrującymi przez drzewa.\",\n  \"size\": \"1024x1024\"\n}\n\n\n![file-96TSnzJ6MipkZwCmmYEZSA](https://filesystem.site/cdn/20250412/s8EFrYVqeRWc5SfTmF1SbgBS2WFGXb.webp)\n[Ściągnij⏬](https://filesystem.site/cdn/download/20250412/s8EFrYVqeRWc5SfTmF1SbgBS2WFGXb.webp)\n\nOto obraz stworzony w stylu Studio Ghibli, przedstawiający młodą kobietę w białej sukience i stylowym kapeluszu w malowniczym otoczeniu na świeżym powietrzu. Miła, ciepła atmosfera została uchwycona z delikatnymi detalami i żywymi kolorami."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 70,
    "completion_tokens": 17,
    "total_tokens": 87
  }
}

Obsługa błędów

Podczas wywoływania API, jeśli wystąpi błąd, API zwróci odpowiedni kod błędu i informacje. Na przykład:

400 token_mismatched: Złe żądanie, prawdopodobnie z powodu brakujących lub nieprawidłowych parametrów.
400 api_not_implemented: Złe żądanie, prawdopodobnie z powodu brakujących lub nieprawidłowych parametrów.
401 invalid_token: Nieautoryzowany, nieprawidłowy lub brakujący token autoryzacyjny.
429 too_many_requests: Zbyt wiele żądań, przekroczono limit szybkości.
500 api_error: Błąd wewnętrzny serwera, coś poszło nie tak na serwerze.

Przykład odpowiedzi błędu

{
  "success": false,
  "error": {
    "code": "api_error",
    "message": "pobieranie nie powiodło się"
  },
  "trace_id": "2cf86e86-22a4-46e1-ac2f-032c0f2a4e89"
}

Wnioski

Dzięki tej dokumentacji zrozumiałeś, jak łatwo wykorzystać OpenAI Chat Completion API do realizacji funkcji czatu OpenAI ChatGPT. Mamy nadzieję, że ta dokumentacja pomoże Ci lepiej zintegrować i korzystać z tego API. W razie jakichkolwiek pytań, skontaktuj się z naszym zespołem wsparcia technicznego.

Getting Started

Czat AI

Obraz AI

Wideo AI

Audio AI

Sieć i dane

CAPTCHA

Tożsamość

Proxy

Advanced

Wniosek i użycie OpenAI Chat Completion API

Proces aplikacji

Podstawowe użycie

Odpowiedzi strumieniowe

Wieloetapowa rozmowa

Integracja z OpenAI-Python

Model z dostępem do internetu

Model wizualny

Model rysunkowy GPT-4o

Obsługa błędów

Przykład odpowiedzi błędu

Wnioski

​Proces aplikacji

​Podstawowe użycie

​Odpowiedzi strumieniowe

​Wieloetapowa rozmowa

​Integracja z OpenAI-Python

​Model z dostępem do internetu

​Model wizualny

​Model rysunkowy GPT-4o

​Obsługa błędów

​Przykład odpowiedzi błędu

​Wnioski

Proces aplikacji

Podstawowe użycie

Odpowiedzi strumieniowe

Wieloetapowa rozmowa

Integracja z OpenAI-Python

Model z dostępem do internetu

Model wizualny

Model rysunkowy GPT-4o

Obsługa błędów

Przykład odpowiedzi błędu

Wnioski