Premier pas avec Spring et ChatGPT

Jihed Kaouech — Tue, 03 Oct 2023 20:40:44 +0000

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

Configuration Clé ChatGPT

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.bootgroupId>
			<artifactId>spring-boot-starter-webartifactId>
		dependency>

Aussi, on a besoin de Lombok pour faciliter la génération du getter et setter.

		<dependency>
			<groupId>org.projectlombokgroupId>
			<artifactId>lombokartifactId>
			<optional>trueoptional>
		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é.

{ request.getHeaders().add("Authorization", "Bearer " + openaiApiKey); return execution.execute(request, body); }); return restTemplate; } }" style="color:#E6E6E6;display:none" aria-label="Copy" class="code-block-pro-copy-button">

@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

https://platform.openai.com/docs/api-reference/completions

L’article Premier pas avec Spring et ChatGPT est apparu en premier sur ji-ka.

Archives des chatgpt - ji-ka