Développer des applications d'IA générative avec Phi-3 SLM, C# Semantic Kernel et Ollama

Introduction

Qu'est-ce que Phi-3 SLM ?

Phi-3 SLM (Small Language Model) est une famille de petits modèles de langage puissants et économiques développés par Microsoft. Ces modèles sont conçus pour offrir d'excellentes performances malgré leur taille réduite et conviennent particulièrement bien aux applications d'IA générative.

Qu'est-ce que Semantic Kernel ?

Semantic Kernel est une bibliothèque et un framework de Microsoft qui permet d'intégrer des modèles de langage dans des langages de programmation comme C#, Python et Java. Il fournit un environnement simple et flexible pour embarquer des capacités IA dans des applications.

Qu'est-ce qu'Ollama ?

Ollama est une plateforme open source qui permet d'exécuter localement sur un ordinateur des grands et petits modèles de langage (LLM, SLM). Développée au départ pour prendre en charge les modèles Llama2, Ollama a depuis élargi sa bibliothèque de modèles et inclut désormais aussi des modèles comme Mistral, Phi-2 et Phi-3. La plateforme offre un moyen simple de faire tourner ces modèles localement sans grosse configuration.

Qu'est-ce qu'une application d'IA générative ?

Une application d'IA générative est une application qui utilise des techniques d'IA, comme les modèles de langage, pour produire du texte, des images ou d'autres contenus. ChatGPT en est un exemple bien connu.

Prérequis

Pour commencer, il faut disposer des éléments suivants :

• installation du .NET Core SDK (version 8.0 ou supérieure)
• installation de Ollama
• installation d'un environnement de développement comme Visual Studio Code

Une fois Ollama installé, il met à disposition une API REST permettant d'accéder aux modèles de langage. Cette API est généralement exposée sur http://localhost:11434.

Comme cet article se concentre sur le modèle Phi-3 SLM, nous devons nous assurer qu'il est disponible dans Ollama :

ollama pull phi3:latest

Cette commande installe le modèle, qui fait environ 2 Go.

Créer une application console simple

Une fois tous les prérequis réunis, nous pouvons créer une application d'IA simple qui utilise le modèle Phi-3 SLM pour générer du texte.

dotnet new console -n OllamaPhi3SlmConsoleApp
cd OllamaPhi3SlmConsoleApp

Ensuite, il faut ajouter les dépendances nécessaires :

dotnet add package Microsoft.Extensions.Hosting
dotnet add package Microsoft.SemanticKernel

Nous pouvons alors commencer l'implémentation. Dans le fichier Program.cs, nous ajoutons le code suivant :

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;
using System.Text;

// create a new host application builder
var builder = Host.CreateEmptyApplicationBuilder(new HostApplicationBuilderSettings
{
    Args = args
});

// register OpenAI chat completion service
builder.Services.AddOpenAIChatCompletion(
    modelId: "phi3",
    apiKey: null,
    endpoint: new Uri("http://localhost:11434") // With local Ollama OpenAI API endpoint
);

var app = builder.Build();

// create a new chat
var chat = app.Services.GetRequiredService<IChatCompletionService>();

// define the chat system message
var chatSystemMessage = Prompt("What am I?");
if (string.IsNullOrWhiteSpace(chatSystemMessage))
{
    SayGoodbye();
    return;
}

// create a new chat history with the chat system message
var chatHistory = new ChatHistory(chatSystemMessage);

// create a string builder to store the AI response
var stringBuilder = new StringBuilder();

// keep the chat running until the user exits
while (true)
{
    // ask the user for input
    var userQuestion = Prompt();
    if (string.IsNullOrWhiteSpace(userQuestion))
    {
        SayGoodbye();
        break;
    }

    // add the user question to the chat history
    chatHistory.AddUserMessage(userQuestion);

    // get the AI response streamed back to the console
    await foreach (var message in chat.GetStreamingChatMessageContentsAsync(chatHistory))
    {
        Say(message);
        stringBuilder.Append(message.Content);
    }

    // add the AI response to the chat history
    chatHistory.AddAssistantMessage(stringBuilder.ToString());
    stringBuilder.Clear();
}

// prompt the user for a question and return the answer
string? Prompt(string question = "?")
{
    Console.WriteLine();
    Console.Write($"{question} ");

    var answer = Console.ReadLine();
    return answer?.Trim();
}

// write a messages to the console
void Say(StreamingChatMessageContent? message) => Console.Write(message);

// say goodbye to the user
void SayGoodbye() => Console.WriteLine("Goodbye!");

Grâce à l'interface IChatCompletionService, il est possible de mener une conversation avec le modèle et d'afficher les réponses dans la console. Le modèle est appelé via l'API REST d'Ollama, exposée sur http://localhost:11434.

Exécuter l'application

Pour exécuter l'application, placez-vous dans le répertoire du projet et lancez la commande suivante :

dotnet run

Résumé

Dans cet article, nous avons vu comment développer des applications d'IA générative avec Phi-3 SLM, C# Semantic Kernel et Ollama. Nous avons créé une application d'IA simple qui utilise Phi-3 SLM pour répondre aux entrées utilisateur. Grâce à Ollama et à Semantic Kernel, nous pouvons exploiter la puissance des modèles de langage dans des applications C# et développer des applications IA interactives.

Besoin d'aide ?

Vous souhaitez développer des applications d'IA générative avec des Small Language Models dans votre entreprise, mais vous hésitez sur l'implémentation et l'intégration ? Nous pouvons vous aider. Contactez-nous via notre page de contact et voyons ensemble comment réussir vos projets IA.

Code source

Le code source complet de l'application est disponible sur GitHub.

Liens complémentaires

• Ollama
• Phi-3 SLM
• Semantic Kernel