Wniosek i korzystanie z OpenAI Chat Completion API

OpenAI ChatGPT to bardzo potężny system konwersacyjny AI, wystarczy wprowadzić prompt, aby w zaledwie kilka sekund wygenerować płynną i naturalną odpowiedź. ChatGPT wyróżnia się w branży swoimi znakomitymi możliwościami rozumienia i generowania języka, a obecnie ChatGPT jest już 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 konsultacje i programowanie kodu, ChatGPT może zapewnić zachwycającą inteligentną pomoc, znacznie zwiększając wydajność pracy i kreatywność ludzi. Ten dokument przedstawia głównie proces korzystania z operacji OpenAI Chat Completion API, dzięki któremu możemy łatwo korzystać z funkcji konwersacji oficjalnego OpenAI ChatGPT.

GPT-6.1 Sol

Użyj model: "gpt-6.1-sol", aby wybrać ten model. Obsługuje wyjście strumieniowe, wywoływanie funkcji, ustrukturyzowane wyjście i wejście obrazów. W pierwszym tygodniu od udostępnienia jest dostępny wyłącznie dla zweryfikowanych posiadaczy ACE T1+ (co najmniej 100 000 ACE) lub autoryzowanych użytkowników; szczegółowy czas udostępnienia zależy od komunikatu o dostępie w konsoli. Poziomy rozumowania obsługują low, medium, high, xhigh i max, tymczasowo nie obsługują none ani minimal. Zaleca się rozpoczęcie od reasoning_effort: "low". Gdy dane wejściowe przekroczą 272 000 tokenów, do całego żądania ma zastosowanie cena za długi kontekst, a opłata zależy od aktualnej ceny w konsoli.

Proces składania wniosku

Aby korzystać z OpenAI Chat Completion API, najpierw przejdź do konsoli Ace Data Cloud, aby uzyskać swój API Token i zachować go na później.

Jeśli nie jesteś jeszcze zalogowany lub zarejestrowany, nastąpi automatyczne przekierowanie na stronę logowania, która zaprosi Cię do rejestracji i zalogowania się, a po zakończeniu automatycznie powrócisz na obecną stronę. Jeden API Token umożliwia wywoływanie wszystkich usług platformy, bez konieczności osobnego składania wniosku dla każdej usługi. Przy pierwszym wniosku otrzymasz bezpłatny limit, który pozwala na darmowe wypróbowanie; gdy limit jest niewystarczający, możesz doładować uniwersalne saldo w konsoli.

📘 Pełna dokumentacja: OpenAI Chat Completion API →

Podstawowe użycie

Następnie można w interfejsie wypełnić odpowiednią treść, jak pokazano na ilustracji:

Przy pierwszym użyciu tego interfejsu musimy wypełnić co najmniej trzy elementy, jednym z nich jest authorization, które można bezpośrednio wybrać z listy rozwijanej. Kolejnym parametrem jest model, model oznacza kategorię modelu z oficjalnej strony OpenAI ChatGPT, którą wybieramy do użycia, tutaj mamy głównie 20 rodzajów modeli, szczegóły można zobaczyć w udostępnianych przez nas modelach. Ostatnim parametrem jest messages, messages to tablica wpisywanych przez nas promptów, jest to tablica, co oznacza, że można jednocześnie przesłać wiele promptów, każdy prompt zawiera role i content, gdzie role oznacza rolę osoby zadającej pytanie, udostępniamy trzy tożsamości, odpowiednio user, assistant, system. Kolejny content to konkretna treść naszego pytania. Jednocześnie można zauważyć, że po prawej stronie generowany jest odpowiedni kod wywołania, można skopiować kod i uruchomić go bezpośrednio, można również bezpośrednio kliknąć przycisk „Try”, aby przeprowadzić test. Często używane opcjonalne parametry:

max_tokens: ogranicza maksymalną liczbę tokenów pojedynczej odpowiedzi.
temperature: losowość generowania, między 0 a 2, im większa wartość, tym większe rozproszenie.
n: ile kandydackich odpowiedzi wygenerować jednocześnie.
response_format: ustawienie formatu zwracanych danych.

Po wywołaniu stwierdzamy, że zwrócony wynik jest następujący:

{
  "id": "chatcmpl-Cmd6uwSxN75F4PAdQSFEO8f2QPs4E",
  "object": "chat.completion",
  "created": 1765706120,
  "model": "gpt-5.5",
  "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
}

Zwrócony wynik zawiera wiele pól, opisanych poniżej:

id, ID wygenerowanego zadania tej konwersacji, używane do jednoznacznej identyfikacji tego zadania konwersacji.
model , wybrany model z oficjalnej strony OpenAI ChatGPT.
choices, informacje o odpowiedzi udzielonej przez ChatGPT na prompt.
usage : informacje statystyczne dotyczące tokenów dla tej pary pytań i odpowiedzi.

W tym choices zawiera informacje o odpowiedzi ChatGPT, choices w nim to ChatGPT, można to zobaczyć, jak pokazano na ilustracji.

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

Odpowiedź strumieniowa

Ten interfejs również obsługuje odpowiedzi strumieniowe, co jest bardzo przydatne przy integracji ze stronami internetowymi i może pozwolić stronie uzyskać efekt wyświetlania znak po znaku. Jeśli chcesz zwracać odpowiedź strumieniowo, możesz zmienić parametr stream w nagłówku żądania na true. Modyfikacja jest pokazana na ilustracji, jednak kod wywołania musi zostać odpowiednio zmieniony, aby obsługiwać odpowiedź strumieniową.

Po zmianie stream na true, API będzie zwracać odpowiednie dane JSON wiersz po wierszu, na poziomie kodu musimy wprowadzić odpowiednie modyfikacje, aby uzyskać wyniki wiersz po wierszu. Przykładowy kod wywołania 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-4",
    "messages": [{"role":"user","content":"hello"}],
    "stream": True
}

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

Efekt wyjściowy jest następujący:

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": "Hi", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " there", "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": " How", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

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

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

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

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

data: {"choices": [{"delta": {"content": " today", "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 choices w data to najnowsza treść odpowiedzi, zgodna z treścią przedstawioną powyżej. choices to nowo dodana treść odpowiedzi, którą można wykorzystać do integracji z własnym systemem. Jednocześnie zakończenie odpowiedzi strumieniowej jest określane na podstawie treści data; jeśli treść ma wartość [DONE], oznacza to, że odpowiedź strumieniowa została całkowicie zakończona. Zwracany wynik data zawiera wiele pól, które opisano poniżej:

id — ID wygenerowanego zadania tej rozmowy, używane do jednoznacznej identyfikacji tego zadania rozmowy.
model — wybrany model z oficjalnej strony OpenAI ChatGPT.
choices — informacje o odpowiedzi udzielonej przez ChatGPT na zapytanie.

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

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: "hello" }],
    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ładowy kod Java:

JSONObject jsonObject = new JSONObject();
jsonObject.put("model", "gpt-4");
jsonObject.put("messages", [{"role":"user","content":"hello"}]);
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 dodatkowo samodzielnie dostosować; zasada działania jest taka sama.

Rozmowa wieloetapowa

Jeśli chcesz zintegrować funkcję rozmowy wieloetapowej, musisz przesłać wiele zapytań w polu messages; konkretny przykład wielu zapytań pokazano na poniższym obrazku:

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"},{"role":"assistant","content":"Hi! How can I assist you today?"},{"role":"user","content":"What I say just now?"}]
}

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

Przez przesłanie wielu zapytań można łatwo zrealizować wieloturową rozmowę i uzyskać następującą odpowiedź:

{
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "You said, \"Hello.\""
      },
      "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 treścią podstawowego użycia; obejmuje to konkretną treść odpowiedzi ChatGPT na wiele rozmów, dzięki czemu można odpowiadać na odpowiednie pytania na podstawie treści wielu rozmów.

Integracja z OpenAI-Python

OpenAI Chat Completion API zachowuje kompatybilność z oficjalnym interfejsem OpenAI i może być bezpośrednio integrowane za pomocą oficjalnego SDK OpenAI-Python; w tym artykule krótko przedstawimy sposób użycia.

Najpierw należy skonfigurować lokalne środowisko Python; ten proces można wyszukać w Google.
Pobierz i zainstaluj środowisko programistyczne, na przykład edytor VSCode.
Skonfiguruj zmienne środowiskowe OpenAI.

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

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

Zastąp sk-xxx własnym kluczem. OPENAI_BASE_URL to pośredniczący interfejs dostępu do OpenAI.

Zainstaluj pakiet zależności projektu

pip install openai

W Mac OS polecenie to:

pip3 install openai

Utwórz przykładowy plik kodu źródłowego

Załóżmy, że utworzyliśmy przykładowy kod index.py, którego konkretna 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": "hello",
        }
    ],
    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ą przeprowadzać wyszukiwanie w internecie na podstawie zapytania i zwracać odpowiednio dostosowane wyniki wyszukiwania internetowego. W tym artykule zademonstrujemy funkcję dostępu do internetu na konkretnym przykładzie. Następnie można wypełnić odpowiednią treść w interfejsie OpenAI Chat Completion API, jak pokazano na ilustracji:

Jednocześnie można zauważyć, że po prawej stronie generowany jest odpowiedni kod wywołania; można skopiować kod i uruchomić go bezpośrednio albo bezpośrednio kliknąć przycisk „Try”, aby go przetestować.

Po wywołaniu zauważamy, że wynik zwracany jest następujący:

{
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "For the latest news in China today, you can check major news websites such as:\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\nThese sources will have up-to-date information on current events in China."
      },
      "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 zostały uzyskane na podstawie wyszukiwania internetowego i zawierają także odpowiednie linki. Informacje odpowiedzi w choices należy renderować za pomocą składni markdown, aby uzyskać najlepsze doświadczenie; ostatecznie pokazuje to również potężną przewagę funkcji dostępu do internetu naszego modelu.

Model wizyjny

gpt-4o to wielomodalny duży model językowy opracowany przez OpenAI; na bazie GPT-4 dodano do niego zdolność rozumienia obrazu. Model ten może jednocześnie przetwarzać dane wejściowe tekstowe i obrazowe, realizując rozumienie oraz generowanie między modalnościami. Przetwarzanie tekstu przy użyciu modelu gpt-4o jest zgodne z opisanym powyżej podstawowym użyciem; poniżej krótko przedstawimy, jak używać możliwości przetwarzania obrazu przez model. Możliwość przetwarzania obrazu przez model gpt-4o jest używana głównie poprzez dodanie pola type do oryginalnej zawartości content; dzięki temu polu można określić, czy przesyłany jest tekst, czy obraz, a tym samym użyć możliwości przetwarzania obrazu modelu gpt-4o. Poniżej głównie opisano wywołanie tej funkcji na dwa sposoby: za pomocą Curl i Python.

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": "What'\''s in this image?"
          },
          {
            "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

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 znajduje się 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)

Następnie można uzyskać poniższy wynik, informacje o polach w wyniku są zgodne z powyższymi, a szczegóły są następujące:

{
  "id": "chatcmpl-123",
  "object": "chat.completion",
  "created": 1677652288,
  "model": "gpt-4-vision-preview",
  "system_fingerprint": "fp_44709d6fcb",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "\n\nTen obraz przedstawia drewnianą kładkę biegnącą przez bujne zielone mokradła."
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 9,
    "completion_tokens": 12,
    "total_tokens": 21
  }
}

Można zauważyć, że treść odpowiedzi jest oparta na obrazie, dlatego za pomocą powyższych dwóch metod można łatwo korzystać z możliwości przetwarzania tekstu i obrazów modelu gpt-4-vision. Oprócz gpt-4o istnieje także model o niższym koszcie, nazywany gpt-4o-mini. gpt-4o-mini to najnowsza generacja dużego modelu językowego opracowanego przez OpenAI, który nie tylko szybko odpowiada, ale jest także tańszy i obsługuje multimodalność. W celu użycia funkcji vision można odwołać się do powyższej treści dotyczącej użycia modelu gpt-4o.

Model do generowania obrazów GPT-4o

Generowanie obrazu na podstawie obrazu referencyjnego

Poniżej znajduje się przykład generowania obrazu w niestandardowym stylu na podstawie obrazu. Najpierw spójrzmy na obraz, który wprowadzamy, jak pokazano poniżej:

Można zauważyć, że obraz referencyjny jest zdjęciem prawdziwej osoby. Możemy zmienić jego styl, na przykład przekształcić go w obraz w stylu anime. Konkretny przykładowy request:

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

Przykładowy wynik:

{
  "id": "chatcmpl-89DPQxbLuyRNzH5YLCPYM5WElV3dm",
  "object": "chat.completion",
  "created": 1781020664,
  "model": "gpt-4o-image",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "\n\n> 🎨 Generowanie...\n\n![https://platform.cdn.acedata.cloud/20260609/0f7b6cf1b14843b1bab8e261fe5765b3.png](https://platform.cdn.acedata.cloud/20260609/0f7b6cf1b14843b1bab8e261fe5765b3.png)\n\n[Kliknij, aby pobrać](https://platform.cdn.acedata.cloud/download/20260609/0f7b6cf1b14843b1bab8e261fe5765b3.png)"
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 100,
    "completion_tokens": 122,
    "total_tokens": 222,
    "prompt_tokens_details": {
      "text_tokens": 93,
      "cached_tokens_details": {}
    },
    "completion_tokens_details": {}
  }
}

Wśród nich message.content w choices to kompletny wygenerowany wynik rozmowy, a obraz jest w nim zawarty w formacie Markdown (link do obrazu jest adresem tymczasowym, prosimy o jego szybkie pobranie i zapisanie). Można zauważyć, że wygenerowany obraz rzeczywiście jest w stylu anime, jak pokazano konkretnie na poniższym obrazie:

Generowanie obrazu wyłącznie na podstawie tekstu

Możemy użyć promptu, aby wygenerował obraz i zwrócił go nam w formie wyniku konwersacyjnego. Poniżej używamy utwórz obraz zachodu słońca w futurystycznym mieście jako przykładu, a konkretny przykład jest następujący:

{
  "model": "gpt-4o-image",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Utwórz obraz zachodu słońca w futurystycznym mieście"
        }
      ]
    }
  ],
  "stream": false
}

Przykładowy wynik:

{
  "id": "chatcmpl-89DqkpQoPGkQqJ6kPKMKWejjLXVxQ",
  "object": "chat.completion",
  "created": 1781020587,
  "model": "gpt-4o-image",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "\n\n> 🎨 Generowanie...\n\n![https://platform.cdn.acedata.cloud/20260609/ed2cca68732540fc99162ddc10ddc153.png](https://platform.cdn.acedata.cloud/20260609/ed2cca68732540fc99162ddc10ddc153.png)\n\n[Kliknij, aby pobrać](https://platform.cdn.acedata.cloud/download/20260609/ed2cca68732540fc99162ddc10ddc153.png)"
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 17,
    "completion_tokens": 104,
    "total_tokens": 121,
    "prompt_tokens_details": {
      "text_tokens": 10,
      "cached_tokens_details": {}
    },
    "completion_tokens_details": {}
  }
}

Można zauważyć, że wynik jest zgodny z promptem, jak konkretnie pokazano poniżej:

Generowanie jednego obrazu z wielu obrazów

Możemy także użyć wielu obrazów referencyjnych do wygenerowania jednego obrazu, na przykład użyć zdjęcia przystojnego mężczyzny i kawy, aby za pomocą tych dwóch obrazów wygenerować obraz przystojnego mężczyzny pijącego kawę. Poniżej znajdują się konkretne obrazy referencyjne:

Poniżej używamy wygeneruj obraz mężczyzny trzymającego kawę i mającego zaraz ją wypić jako przykładu, a konkretny przykład jest następujący:

{
  "model": "gpt-4o-image",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Wygeneruj chłopaka trzymającego kawę i wyglądającego tak, jakby zaraz miał ją wypić"
        },
        {
          "type": "image_url",
          "image_url": {
            "url": "https://cdn.acedata.cloud/pqquv3.jpg"
          }
        },
        {
          "type": "image_url",
          "image_url": {
            "url": "https://cdn.acedata.cloud/h8j2i0.jpg"
          }
        }
      ]
    }
  ],
  "stream": false
}

Przykładowy wynik:

{
  "id": "chatcmpl-89DnHbbzOIQvU1VzJrNjzMU8BRUgG",
  "object": "chat.completion",
  "created": 1781021018,
  "model": "gpt-4o-image",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "\n\n> 🎨 Generowanie...\n\n![https://platform.cdn.acedata.cloud/20260610/f1d9ddee3c304230a9f92929f04b95be.png](https://platform.cdn.acedata.cloud/20260610/f1d9ddee3c304230a9f92929f04b95be.png)\n\n[Kliknij, aby pobrać](https://platform.cdn.acedata.cloud/download/20260610/f1d9ddee3c304230a9f92929f04b95be.png)"
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 193,
    "completion_tokens": 116,
    "total_tokens": 309,
    "prompt_tokens_details": {
      "text_tokens": 186,
      "cached_tokens_details": {}
    },
    "completion_tokens_details": {}
  }
}

Można zauważyć, że wygenerowany wynik rzeczywiście powstał z połączenia dwóch obrazów, poniżej przedstawiono konkretny rezultat:

Obsługa błędów

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

400 token_mismatched：Nieprawidłowe żądanie, prawdopodobnie z powodu brakujących lub nieprawidłowych parametrów.
400 api_not_implemented：Nieprawidłowe żądanie, prawdopodobnie z powodu brakujących lub nieprawidłowych parametrów.
401 invalid_token：Brak autoryzacji, nieprawidłowy lub brakujący token autoryzacyjny.
429 too_many_requests：Zbyt wiele żądań, przekroczono limit częstotliwości.
500 api_error：Wewnętrzny błąd serwera, coś poszło nie tak na serwerze.

Przykład odpowiedzi błędu

{
  "success": false,
  "error": {
    "code": "api_error",
    "message": "fetch failed"
  },
  "trace_id": "2cf86e86-22a4-46e1-ac2f-032c0f2a4e89"
}

Wnioski

Dzięki temu dokumentowi dowiedziałeś się już, jak korzystać z OpenAI Chat Completion API, aby łatwo wdrożyć funkcję konwersacji oficjalnego OpenAI ChatGPT. Mamy nadzieję, że ten dokument pomoże Ci lepiej zintegrować i korzystać z tego API. W razie jakichkolwiek pytań skontaktuj się w dowolnym momencie z naszym zespołem wsparcia technicznego.

Getting Started

Czat AI

Obraz AI

Wideo AI

Audio AI

Sieć i dane

CAPTCHA

Tożsamość

Coding

Więcej przewodników

Wniosek i korzystanie z OpenAI Chat Completion API

GPT-6.1 Sol

Proces składania wniosku

Podstawowe użycie

Odpowiedź strumieniowa

Rozmowa wieloetapowa

Integracja z OpenAI-Python

Model z dostępem do internetu

Model wizyjny

Model do generowania obrazów GPT-4o

Generowanie obrazu na podstawie obrazu referencyjnego

Generowanie obrazu wyłącznie na podstawie tekstu

Generowanie jednego obrazu z wielu obrazów

Obsługa błędów

Przykład odpowiedzi błędu

Wnioski

​GPT-6.1 Sol

​Proces składania wniosku

​Podstawowe użycie

​Odpowiedź strumieniowa

​Rozmowa wieloetapowa

​Integracja z OpenAI-Python

​Model z dostępem do internetu

​Model wizyjny

​Model do generowania obrazów GPT-4o

​Generowanie obrazu na podstawie obrazu referencyjnego

​Generowanie obrazu wyłącznie na podstawie tekstu

​Generowanie jednego obrazu z wielu obrazów

​Obsługa błędów

​Przykład odpowiedzi błędu

​Wnioski

GPT-6.1 Sol

Proces składania wniosku

Podstawowe użycie

Odpowiedź strumieniowa

Rozmowa wieloetapowa

Integracja z OpenAI-Python

Model z dostępem do internetu

Model wizyjny

Model do generowania obrazów GPT-4o

Generowanie obrazu na podstawie obrazu referencyjnego

Generowanie obrazu wyłącznie na podstawie tekstu

Generowanie jednego obrazu z wielu obrazów

Obsługa błędów

Przykład odpowiedzi błędu

Wnioski