public openai client php
1.6.0
Este pacote não é mais suportado ou mantido.
O cliente de API Tectalic OpenAi REST é um pacote que fornece uma maneira conveniente e direta de interagir com a API do OpenAI do seu aplicativo PHP.
Suporta ChatGPT , GPT-4 , GPT-3.5 , GPT-3 , Codex , Dall · E , Whisper , Tuneing Fine , modelos de incorporação e moderação , com objetos de transferência de dados totalmente digitados (DTOs) para todas as solicitações e respostas e suporte autocompleto IDE.
Mais informações estão disponíveis em https://tectalic.com/apis/openai.
Este é um pacote não oficial e não possui afiliações com o OpenAI.
A integração do OpenAI em seu aplicativo agora é tão simples quanto algumas linhas de código.
$ openaiClient = Tectalic OpenAi Manager :: build (
new GuzzleHttp Client (),
new Tectalic OpenAi Authentication ( getenv ( ' OPENAI_API_KEY ' ))
);
/** @var TectalicOpenAiModelsChatCompletionsCreateResponse $response */
$ response = $ openaiClient -> chatCompletions ()-> create (
new Tectalic OpenAi Models ChatCompletions CreateRequest ([
' model ' => ' gpt-4 ' ,
' messages ' => [
[
' role ' => ' user ' ,
' content ' => ' Will using a well designed and supported third party package save time? '
],
],
])
)-> toModel ();
echo $ response -> choices [ 0 ]-> message -> content ;
// Yes, using a well-designed and supported third-party package can save time during software development.
// It allows you to focus on the core functionality of your application without having to reinvent the wheel or spend resources developing the same functionality from scratch.
// A good third-party package can provide reliability, efficiency, and continued support with updates and bug fixes, which in turn facilitates faster development and a more stable final product.
// Additionally, using widely adopted packages can also increase the chances of compatibility with other software components and make it easier for other developers to understand and work with your code.Saiba mais sobre a conclusão do bate -papo.
Este manipulador suporta os modelos GPT-3.5 e GPT-4 :
Os modelos GPT-3.5 suportados incluem gpt-3.5-turbo e muito mais.
Os modelos GPT-4 suportados incluem gpt-4 e muito mais.
NOTA: O GPT-4 está atualmente em uma versão beta limitada e só é acessível àqueles que receberam acesso. Por favor, veja aqui para obter detalhes e instruções sobre como ingressar na lista de espera.
Se você receber um erro 404 ao tentar usar o GPT-4, sua conta do OpenAI não recebeu acesso.
O exemplo a seguir usa o modelo gpt-3.5-turbo-0613 para demonstrar chamadas de função.
Ele converte a linguagem natural em uma chamada de função, que pode ser executada em seu aplicativo.
$ openaiClient = Tectalic OpenAi Manager :: build (
new GuzzleHttp Client (),
new Tectalic OpenAi Authentication ( getenv ( ' OPENAI_API_KEY ' ))
);
/** @var TectalicOpenAiModelsChatCompletionsCreateResponse $response */
$ response = $ openaiClient -> chatCompletions ()-> create ( new CreateRequest ([
' model ' => ' gpt-3.5-turbo-0613 ' ,
' messages ' => [
[ ' role ' => ' user ' , ' content ' => ' What ' s the weather like in Boston? ' ]
],
' functions ' => [
[
' name ' => ' get_current_weather ' ,
' description ' => ' Get the current weather in a given location ' ,
' parameters ' => new Tectalic OpenAi Models ChatCompletions CreateRequestFunctionsItemParameters (
[
' type ' => ' object ' ,
' properties ' => [
' location ' => [
' type ' => ' string ' ,
' description ' => ' The worldwide city and state, e.g. San Francisco, CA ' ,
],
' format ' => [
' type ' => ' string ' ,
' description ' => ' The temperature unit to use. Infer this from the users location. ' ,
' enum ' => [ ' celsius ' , ' farhenheit ' ],
],
' num_days ' => [
' type ' => ' integer ' ,
' description ' => ' The number of days to forecast ' ,
],
],
' required ' => [ ' location ' , ' format ' , ' num_days ' ],
]
)
]
],
' function_call ' => ' auto ' ,
]))-> toModel ();
$ params = json_decode ( $ response -> choices [ 0 ]-> message -> function_call -> arguments , true );
var_dump ( $ params );
// array(3) {
// 'location' =>
// string(6) "Boston"
// 'format' =>
// string(7) "celsius"
// 'num_days' =>
// int(1)
//}Saiba mais sobre a chamada de funções.
$ openaiClient = Tectalic OpenAi Manager :: build ( new GuzzleHttp Client (), new Tectalic OpenAi Authentication ( getenv ( ' OPENAI_API_KEY ' )));
/** @var TectalicOpenAiModelsCompletionsCreateResponse $response */
$ response = $ openaiClient -> completions ()-> create (
new Tectalic OpenAi Models Completions CreateRequest ([
' model ' => ' text-davinci-003 ' ,
' prompt ' => ' Will using a third party package save time? ' ,
])
)-> toModel ();
echo $ response -> choices [ 0 ]-> text ;
// Using a third party package can save time because you don't have to write the code yourself. Este manipulador suporta todos os modelos GPT-3, incluindo text-davinci-003 , text-davinci-002 e muito mais.
Saiba mais sobre a conclusão do texto.
$ openaiClient = Tectalic OpenAi Manager :: build ( new GuzzleHttp Client (), new Tectalic OpenAi Authentication ( getenv ( ' OPENAI_API_KEY ' )));
/** @var TectalicOpenAiModelsCompletionsCreateResponse $response */
$ response = $ openaiClient -> completions ()-> create (
new Tectalic OpenAi Models Completions CreateRequest ([
' model ' => ' code-davinci-002 ' ,
' prompt ' => " // PHP 8 n // A variable that saves the current date and time " ,
' max_tokens ' => 256 ,
' stop ' => " ; " ,
])
)-> toModel ();
echo $ response -> choices [ 0 ]-> text ;
// $now = date("Y-m-d G:i:s") Os modelos Codex suportados incluem code-davinci-002 e code-cushman-001 .
Saiba mais sobre a conclusão do código.
$ openaiClient = Tectalic OpenAi Manager :: build ( new GuzzleHttp Client (), new Tectalic OpenAi Authentication ( getenv ( ' OPENAI_API_KEY ' )));
/** @var TectalicOpenAiModelsImagesGenerationsCreateResponse $response */
$ response = $ openaiClient -> imagesGenerations ()-> create (
new Tectalic OpenAi Models ImagesGenerations CreateRequest ([
' prompt ' => ' A cute baby sea otter wearing a hat ' ,
' size ' => ' 256x256 ' ,
' n ' => 5
])
)-> toModel ();
foreach ( $ response -> data as $ item ) {
var_dump ( $ item -> url );
}Saiba mais sobre a geração de imagens.
$ openaiClient = Tectalic OpenAi Manager :: build ( new GuzzleHttp Client (), new Tectalic OpenAi Authentication ( getenv ( ' OPENAI_API_KEY ' )));
/** @var TectalicOpenAiModelsAudioTranscriptionsCreateResponse $response */
$ response = $ openaiClient -> audioTranscriptions ()-> create (
new Tectalic OpenAi Models AudioTranscriptions CreateRequest ([
' file ' => ' /full/path/to/audio/file.mp3 ' ,
' model ' => ' whisper-1 ' ,
])
)-> toModel ();
echo $ response -> text ;
// Your audio transcript in your source language... Os modelos sussurros suportados incluem whisper-1 .
Saiba mais sobre o discurso para texto, incluindo os mais de 50 idiomas suportados.
$ openaiClient = Tectalic OpenAi Manager :: build ( new GuzzleHttp Client (), new Tectalic OpenAi Authentication ( getenv ( ' OPENAI_API_KEY ' )));
/** @var TectalicOpenAiModelsAudioTranslationsCreateResponse $response */
$ response = $ openaiClient -> audioTranslations ()-> create (
new Tectalic OpenAi Models AudioTranslations CreateRequest ([
' file ' => ' /full/path/to/audio/file.mp3 ' ,
' model ' => ' whisper-1 ' ,
])
)-> toModel ();
echo $ response -> text ;
// Your audio transcript in English... Os modelos sussurros suportados incluem whisper-1 .
Saiba mais sobre o discurso para texto, incluindo os mais de 50 idiomas suportados.
Precisa de ajuda para começar? Veja nosso guia: como criar um aplicativo usando a API OpenAI.
Instale o pacote em seu projeto:
composer require tectalic/openaiDepois de instalar o pacote de cliente da API Tectalic OpenAi Rest API em seu projeto, verifique se também possui um cliente compatível com PSR-18 HTTP, como 'Guzzle' ou o Symfony 'HTTP Client'.
Você pode usar o seguinte amostra de código e personalizá -lo para se adequar ao seu aplicativo.
// Load your project's composer autoloader (if you aren't already doing so).
require_once ( __DIR__ . ' /vendor/autoload.php ' ); use Symfony Component HttpClient Psr18Client ;
use Tectalic OpenAi Authentication ;
use Tectalic OpenAi Client ;
use Tectalic OpenAi Manager ;
// Build a Tectalic OpenAI REST API Client globally.
$ auth = new Authentication ( getenv ( ' OPENAI_API_KEY ' ));
$ httpClient = new Psr18Client ();
Manager :: build ( $ httpClient , $ auth );
// or
// Build a Tectalic OpenAI REST API Client manually.
$ auth = new Authentication ( getenv ( ' OPENAI_API_KEY ' ));
$ httpClient = new Psr18Client ();
$ client = new Client ( $ httpClient , $ auth , Manager :: BASE_URI ); Para autenticar suas solicitações de API, você precisará fornecer um objeto Authentication ( $auth ) ao chamar Manager::build() .
A autenticação da API OpenAI é por autenticação do portador HTTP.
Consulte a documentação da API do OpenAI para obter mais detalhes sobre a obtenção de suas credenciais de autenticação.
No código de uso acima, personalize o construtor Authentication para suas necessidades. Por exemplo, provavelmente precisará adicionar uma variável de ambiente OPENAI_API_KEY ao seu sistema.
A classe principal com a qual você interagirá é a classe Client ( TectalicOpenAiClient ).
Essa classe Client também contém os métodos auxiliares que permitem acessar rapidamente os 19 manipuladores de API.
Veja abaixo uma lista completa de manipuladores e métodos suportados.
Este pacote suporta 28 métodos de API, agrupados em 19 manipuladores de API.
Consulte a tabela abaixo para obter uma lista completa de manipuladores e métodos da API.
| Classe de manipulador de API e nome do método | Descrição | Verbo API e URL |
|---|---|---|
AudioTranscriptions::create() | Transcreve áudio para o idioma de entrada. | POST /audio/transcriptions |
AudioTranslations::create() | Traduz áudio para o inglês. | POST /audio/translations |
ChatCompletions::create() | Cria uma resposta de modelo para a conversa de bate -papo fornecida. | POST /chat/completions |
Completions::create() | Cria uma conclusão para o prompt e os parâmetros fornecidos. | POST /completions |
Edits::create() | POST /edits | |
Embeddings::create() | Cria um vetor de incorporação que representa o texto de entrada. | POST /embeddings |
Files::list() | Retorna uma lista de arquivos que pertencem à organização do usuário. | GET /files |
Files::create() | Carregue um arquivo que contém documentos a serem usados em vários pontos de extremidade/recursos. Atualmente, o tamanho de todos os arquivos enviados por uma organização pode ser de até 1 GB. Entre em contato conosco se precisar aumentar o limite de armazenamento. | POST /files |
Files::retrieve() | Retorna informações sobre um arquivo específico. | GET /files/{file_id} |
Files::delete() | Exclua um arquivo. | DELETE /files/{file_id} |
FilesContent::download() | Retorna o conteúdo do arquivo especificado. | GET /files/{file_id}/content |
FineTunes::list() | GET /fine-tunes | |
FineTunes::create() | A resposta inclui detalhes do trabalho envolvido, incluindo o status do trabalho e o nome dos modelos ajustados, uma vez concluídos. Saiba mais sobre o ajuste fino | POST /fine-tunes |
FineTunes::retrieve() | Saiba mais sobre o ajuste fino | GET /fine-tunes/{fine_tune_id} |
FineTunesCancel::cancelFineTune() | POST /fine-tunes/{fine_tune_id}/cancel | |
FineTunesEvents::listFineTune() | GET /fine-tunes/{fine_tune_id}/events | |
FineTuningJobs::listPaginated() | Liste os empregos de ajuste fina de sua organização | GET /fine_tuning/jobs |
FineTuningJobs::create() | Cria um trabalho que tunha um modelo especificado de um determinado conjunto de dados. A resposta inclui detalhes do trabalho envolvido, incluindo o status do trabalho e o nome dos modelos ajustados, uma vez concluídos. Saiba mais sobre o ajuste fino | POST /fine_tuning/jobs |
FineTuningJobs::retrieve() | Obtenha informações sobre um emprego de ajuste fino. Saiba mais sobre o ajuste fino | GET /fine_tuning/jobs/{fine_tuning_job_id} |
FineTuningJobsCancel::fineTuning() | Cancelar imediatamente um trabalho de ajuste. | POST /fine_tuning/jobs/{fine_tuning_job_id}/cancel |
FineTuningJobsEvents::listFineTuning() | Obtenha atualizações de status para um trabalho de ajuste fino. | GET /fine_tuning/jobs/{fine_tuning_job_id}/events |
ImagesEdits::createImage() | Cria uma imagem editada ou estendida, dada uma imagem original e um prompt. | POST /images/edits |
ImagesGenerations::create() | Cria uma imagem com um prompt. | POST /images/generations |
ImagesVariations::createImage() | Cria uma variação de uma determinada imagem. | POST /images/variations |
Models::list() | Liste os modelos atualmente disponíveis e fornece informações básicas sobre cada um, como o proprietário e a disponibilidade. | GET /models |
Models::retrieve() | Recupera uma instância do modelo, fornecendo informações básicas sobre o modelo como o proprietário e a permissão. | GET /models/{model} |
Models::delete() | Exclua um modelo de ajuste fino. Você deve ter o papel do proprietário em sua organização para excluir um modelo. | DELETE /models/{model} |
Moderations::create() | Classifica se o texto violar a política de conteúdo do OpenAi | POST /moderations |
Os métodos depreciados estão listados com greve formatação. Por favor, não use esses métodos, pois eles serão removidos em uma versão futura.
Existem duas maneiras de fazer uma solicitação ao método de manipulador de API e API nomeado:
Se você construiu o cliente para estar acessível globalmente, poderá usar a classe de manipulador de API relevante diretamente:
use Tectalic OpenAi Handlers AudioTranscriptions ;
( new AudioTranscriptions ())-> create ();Como alternativa, você pode acessar todos os manipuladores de API da classe cliente usando a classe Client:
$ client -> audioTranscriptions ()-> create ();Depois de fazer uma solicitação usando um dos dois métodos descritos acima, a próxima etapa é acessar a resposta.
Você pode acessar a resposta de maneiras diferentes. Escolha o seu preferido.
As respostas do modelo são as classes PHP do estilo de transferência de dados (DTO), com propriedades públicas para cada propriedade da API.
Eles oferecem uma maneira estruturada de recuperar a resposta de uma solicitação de API.
Todos os modelos de resposta são uma instância de TectalicOpenAiModelsAbstractModel ou TectalicOpenAiModelsAbstractModelCollection .
Depois de executar a solicitação, use o método fluente ->toModel() para o método da API:
use Tectalic OpenAi Handlers AudioTranscriptions ;
$ model = ( new AudioTranscriptions ())-> create ()-> toModel (); A chamada toModel() de cada método da API retornará o tipo de classe de modelo apropriado para o método da API que você acabou de ligar.
Depois de executar a solicitação, use o método fluente ->toArray() para o método da API:
use Tectalic OpenAi Handlers AudioTranscriptions ;
$ array = ( new AudioTranscriptions ())-> create ()-> toArray ();Na matriz associativa resultante, as teclas da matriz corresponderão aos nomes das propriedades públicas na classe de modelo relevante.
Se você precisar acessar a resposta bruta ou inspecionar os cabeçalhos HTTP, use o método fluente ->getResponse() no método da API. Ele retornará um PsrHttpMessageResponseInterface :
use Tectalic OpenAi Handlers AudioTranscriptions ;
$ response = ( new AudioTranscriptions ())-> create ()-> getResponse (); Ao executar solicitações com o cliente Tectalic OpenAI REST API , cenários específicos causarão uma exceção TectalicOpenAiExceptionClientException . Por favor, veja abaixo para obter detalhes.
Manager Uma LogicException será lançada se a função Manager::build() for chamada várias vezes, ou se Manager::access() for chamado antes de ligar para Manager::build() .
O cliente da API Tectalic OpenAi REST depende de um cliente HTTP compatível com PSR-18, e esse cliente HTTP não deve lançar uma exceção para os códigos de resposta HTTP sem sucesso.
Um código de resposta malsucedido é classificado como aquele que não está no intervalo de 200 a 299 (inclusive). Exemplos de códigos de resposta malsucedidos incluem:
100 - 199 )300 - 399 )400 - 499 )500 - 599 )Se ocorrer um código de resposta malsucedido:
toModel() do manipulador da API lançará uma ClientException .toArray() do manipulador da API retornará o corpo da resposta e não lançará uma ClientException .getResponse() do manipulador da API retornará a resposta bruta e não lançará uma ClientException . Abaixo está um exemplo de como você pode usar um bloco try / catch ao executar uma solicitação para que você possa detectar e lidar com erros inesperados.
use Tectalic OpenAi Authentication ;
use Tectalic OpenAi Client ;
use Tectalic OpenAi ClientException ;
use Tectalic OpenAi Manager ;
// Build a Tectalic OpenAI REST API Client globally.
$ auth = new Authentication ( ' token ' );
Manager :: build ( $ httpClient , $ auth );
$ handler = new AudioTranscriptions ();
// Perform a request
try {
$ model = $ handler -> create ()-> toModel ();
// Do something with the response model...
} catch ( ClientException $ e ) {
// Error response received. Retrieve the HTTP response code and response body.
$ responseBody = $ handler -> toArray ();
$ responseCode = $ handler -> getResponse ()-> getStatusCode ();
// Handle the error...
} Se o seu cliente HTTP de escolha lançar uma exceção que não seja ClientException , o Client de API Tectalic OpenAi Rest API e suas classes de manipulador de API permitirão que essas exceções aumentem.
Consulte a documentação do seu cliente HTTP para obter mais detalhes sobre o manuseio de exceções.
O pacote de cliente da API Tectalic OpenAi Rest API inclui vários tipos de testes de phpunit automatizados para verificar a operação correta:
Para executar esses testes, você precisará instalar o pacote de cliente da API REST TETALIC OPENAI com suas dependências dev (ou seja, não usando o sinalizador --no-dev ao executar o Composer).
Esses testes de phpunit foram projetados para:
Client e Manager .Os testes de unidade podem ser executados usando o seguinte comando, que precisa ser executado no diretório raiz deste pacote.
composer test:unitOs testes de unidade não realizam nenhum pedido real contra a API OpenAI.
Os testes de unidade estão localizados no diretório tests/Unit .
Os testes de integração estão localizados no diretório tests/Integration .
Esses testes de phpunit foram projetados para confirmar que cada método da API analisa uma resposta válida, de acordo com a especificação do OpenAI API OpenAPI. Fora da caixa Os testes de integração foram projetados para funcionar com o servidor simulado do Prism.
Verifique se o prisma está instalado. Consulte a documentação do Prism para obter detalhes sobre como instalar o Prism.
Depois que o Prism é instalado, você pode executar o prisma e os testes de integração lado a lado em janelas de terminal separadas ou usando o seguinte comando, que precisam ser executados no diretório raiz deste pacote.
echo " > Starting Prism server "
prism mock tests/openapi.yaml > /dev/null 2>&1 &
PRISM_PID= $!
sleep 2
echo " => Started "
composer test:integration
kill $PRISM_PIDEsses comandos iniciarão o Prism Mock Server, executarão os testes de integração e interromperão o servidor Mock Prism quando os testes forem concluídos.
Nesse caso, os testes de integração não realizam nenhum pedido real contra a API OpenAI.
Ao definir a variável de ambiente OPENAI_CLIENT_TEST_BASE_URI , você pode definir um destino de endpoint da API diferente para os testes de integração.
Por exemplo, em vez de usar o PRISM, você pode usar um servidor de zombaria/estadiamento/teste diferente de sua escolha ou pode usar os pontos de extremidade ao vivo da API da API.
Não se esqueça de definir as credenciais apropriadas nas variáveis de ambiente do OPENAI_CLIENT_TEST_AUTH_USERNAME OPENAI_CLIENT_TEST_AUTH_PASSWORD .
Depois que sua configuração estiver concluída, basta executar o seguinte comando.
composer test:integrationNão recomendamos a execução de testes de integração contra os terminais do Live OpenAI API. Isso ocorre porque os testes enviarão dados de exemplo para todos os pontos de extremidade, o que pode resultar em novos dados sendo criados ou os dados existentes sendo excluídos.
Se você estiver escrevendo seus próprios testes, provavelmente precisará zombar das respostas da API OpenAI .
Uma maneira de fazer isso é instalar o pacote php-http/mock-client em seu projeto e, em seguida, usar a classe HttpMockClient (em vez de um cliente PSR-18 real) ao instantar o cliente API Tectalic OpenAi Rest .
Isso permite zombar das respostas da API do OpenAI , em vez de executar solicitações reais.
Consulte a documentação simulada do cliente para obter detalhes.
Se você tiver alguma dúvida ou feedback, use o quadro de discussão.
Este software é o copyright (c) 2022-presente Tectalic.
Para informações sobre direitos autorais e licença, consulte o arquivo de licença .
