Dans ce tutoriel, nous allons découvrir l’api ChatGPT d’openAI. D’abord, on va voir comment tester l’api ChatGPT et comprendre son model de donnée. Ensuite, nous allons créer une application Spring Boot qui génère des réponses à partir de cette API.
1 API ChatGPT
l’API qu’on va utiliser dans ce tutorial s’appelle chat completation. Commençant par jeter un coup d’œil à cette API pour comprendre son modèle.
1.1 Accès à l’API
Pour utiliser l’API chat completation, vous devez obtenir un accès auprès d’OpenAI
1.2 Utilisation de l’API
Utilisez la clé API pour faire des requêtes à l’API « completions » en utilisant des appels HTTP. Il faut fournir un message qui est le texte d’entrée ou la question que vous souhaitez poser et l’API renvoie une réponse générée par le moteur GPT.
curl -X POST -s https://api.openai.com/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${CLE_API}" \
-d '{
"model": "gpt-3.5-turbo",
"messages": [
{
"role": "user",
"content": "Hello!"
}
]
}'Assurez vous de remplacer « ${CLE_API} » par votre clé API réelle et de personnaliser les autres paramètres de la requête en fonction de vos besoins.
- model : ID / version du modèle à utiliser. Pour cet exemple, on va utilisée le denier model de la version publique (gpt-3.5-turbo), ceci dit, il existe d’autres models aussi, voir ici.
- messages : Une liste de messages comprenant la conversation. Chaque message nécessite deux champs:
- role : spécifie l’expéditeur du message
- content: le message réel à envoyer
1.3 Réponse de l’API
La réponse de l’API sera au format JSON avec des métadonnées et un champ « choices« . Ce champ est une liste qui contient un index et une liste de messages.
{
"id": "chatcmpl-123",
"object": "chat.completion",
"created": 1589478378,
"model": "gpt-3.5-turbo",
"choices": [{
"index": 0,
"message": {
"role": "assistant",
"content": "\n\nHello there, how may I assist you today?",
},
"finish_reason": "stop"
}],
"usage": {
"prompt_tokens": 5,
"completion_tokens": 7,
"total_tokens": 12
}
}2 Spring et ChatGPT
Nous allons créer une application Spring Boot contenant une API Rest qui accepte un message dans les paramètres de la requête, le transmet à l’API ChatGPT et renvoie le message de retour.
2.1 Dépendances
Créer un projet du starter Spring boot et ajouter la dépendance « spring-boot-starter-web«
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>Aussi, on a besoin de Lombok pour faciliter la génération du getter et setter.
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>2.2 Configuration
Dans cette article on va faire simple du coup on va utiliser ResTemplate pour s’interfacer avec OpenAI. On doit ajouter un intercepteur pour ajouter la clé.
@Configuration
public class OpenAIConfig {
@Value("${application.openai.key}")
private String openaiApiKey;
@Bean
@Qualifier("openaiRestTemplate")
public RestTemplate openaiRestTemplate() {
RestTemplate restTemplate = new RestTemplate();
restTemplate.getInterceptors().add((request, body, execution) -> {
request.getHeaders().add("Authorization", "Bearer " + openaiApiKey);
return execution.execute(request, body);
});
return restTemplate;
}
}2.3 Modèle
Créons maintenant le modèle correspondant au modèle de l’api ChatGPT.
- Classe Message :
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Message {
private String role;
private String content;
}- Classe Choice :
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Choice {
private int index;
private Message message;
}
Ensuite, créons note model request et response.
- Classe ChatRequest :
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ChatRequest {
private String model;
private List<Message> messages;
@Builder
public ChatRequest(String model, String message) {
this.model = model;
this.messages = new ArrayList<>();
this.messages.add(new Message("user", message));
}
}- Classe de réponse :
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ChatResponse {
private String id;
private List<Choice> choices;
@JsonProperty("finish_reason")
private String finishReason;
}2.4 Service
La classe service permet d’appeler notre client OpenAI :
@Service
@RequiredArgsConstructor
public class ChatService {
@Qualifier("openaiRestTemplate")
private final RestTemplate restTemplate;
@Value("${application.openai.model}")
private String model;
@Value("${application.openai.url}")
private String apiUrl;
public String sendMessage(String message) {
ChatRequest request = ChatRequest.builder()
.model(model)
.message(message)
.build();
ChatResponse response = restTemplate.postForObject(apiUrl, request, ChatResponse.class);
if (response == null || CollectionUtils.isEmpty(response.getChoices())) {
return "No response";
}
return response.getChoices().get(0).getMessage().getContent();
}
}2.5 Api d’entré
Exposant maintenant notre Api :
@RestController
@RequiredArgsConstructor
public class ChatController {
private final ChatService chatService;
@GetMapping("/chat")
public String chat(@RequestParam String message) {
return chatService.sendMessage(message);
}
}2.6 Propriétés
Ajoutons dans le fichier « application.yml » les paramètres qu’on a déclaré.
application:
openai:
model: gpt-3.5-turbo
url: https://api.openai.com/v1/chat/completions
key: ${your_api_key}3 Exécution
Désormé, on peut lancer l’application et appeler notre api via http://localhost:8080/chat?message=Hello!
4 Code source
L’exemple complet de ce tutorial est disponible sur GitHub
5. Référence
https://platform.openai.com/docs/models/model-endpoint-compatibility
