Cómo Usar Phi-3 con OLlama y C# en tu Entorno Local

🚀 El desarrollo de aplicaciones inteligentes ha avanzado considerablemente en los últimos años. Uno de los motores que impulsan esta innovación es la integración de modelos de lenguaje avanzados como Phi-3. OLlama es una biblioteca que facilita el uso de estos modelos en diversas plataformas y lenguajes de programación, incluyendo C#. En este artículo, te guiaré paso a paso sobre cómo usar Phi-3 con OLlama y C# en tu entorno local.

🤔 ¿Qué es Phi-3? Descubre el Potencial de Phi-3 en tus Proyectos de IA

Phi-3 es una familia de modelos de inteligencia artificial abiertos desarrollados por Microsoft. Son modelos de lenguaje pequeños (SLM) muy eficientes y rentables, que superan a otros modelos de su mismo tamaño y más grandes en tareas de lenguaje, razonamiento, codificación y matemáticas. Está disponible en Microsoft Azure AI Studio, Hugging Face y Ollama, y rinde mejor que modelos el doble de grandes, incluso superando al GPT-3.5 en varios puntos de referencia clave.

🔍 ¿Qué es OLlama? Implementa Modelos de Lenguaje en tu Máquina Local

Ollama es una herramienta ligera y extensible para ejecutar y personalizar modelos de lenguaje grandes en tu propia máquina. Te permite trabajar con modelos como Llama 3, Mistral, Gemma y otros. Puedes usar la interfaz de línea de comandos (CLI), una API REST o integraciones web y de escritorio. Además, Ollama proporciona una biblioteca de modelos preconstruidos que se pueden utilizar fácilmente en diversas aplicaciones.

🔧 ¿Qué es Semantic Kernel? Facilita el Uso de Modelos de IA en .NET

Semantic Kernel es una biblioteca de código abierto que te permite crear fácilmente soluciones de IA que pueden llamar a tu código existente. Como SDK altamente extensible, puedes usar Semantic Kernel para trabajar con modelos de OpenAI, Azure OpenAI, Hugging Face, etc.

Te permite trabajar con varios modelos mediante sus propios SDK de .NET y endpoints REST, el Semantic Kernel facilita la tarea a la vez que minimiza el impacto en el código. Proporciona un conjunto común de abstracciones que puedes usar para acceder a modelos mediante la inserción de dependencias en .NET.

🛠️ Paso 1: Instalar OLlama en tu Entorno Local

Para esto será necesario ir al sitio web de OLlama: descargar OLlama.

Le damos a descargar, en mi caso descargo la versión de Windows y le doy a instalar directamente.

Una vez terminado, abro una consola que puede ser CMD, Powershell, o la que más te guste y ejecuto el siguiente comando para asegurarme que se instaló correctamente.

ollama --version

📥 Paso 2: Descargar y Ejecutar Phi-3 en tu PC

Ya que OLlama ya está instalado, vamos a usarlo para descargar nuestro modelo de inteligencia artificial Phi-3 3.8b. Existen varias versiones de Phi-3, lo que más varía es su tamaño. La versión de 3.8b representa la versión de Phi-3 que está entrenada con 3.8 billones de parámetros y pesa tan solo 2.8GB. También existe una versión de 14 billones de parámetros que pesa casi 8 GB. Como nuestro objetivo es correr un modelo de inteligencia artificial en nuestras PC de pocos recursos, vamos a usar la versión de 3.8b.

Descargar Phi-3 3.8b

Para descargar este modelo ejecutamos el siguiente comando:

ollama run phi3:3.8b

💻 Paso 3: Probar Phi-3 en Postman

OLlama nos provee una interfaz de web API con la cual podemos interactuar con nuestro modelo de inteligencia artificial. En nuestro caso, podemos poner a prueba a Phi-3 desde el mismo Postman:

curl --location 'http://localhost:11434/api/chat' \
--header 'Content-Type: application/json' \
--data '{
    "model": "phi3:3.8b",
    "messages": [
        {
            "role": "user",
            "content": "¿Cuál es la capital de Argentina?"
        }
    ],
    "stream": false
}'

🔨 Paso 4: Crear Proyecto Consola e Instalar Microsoft.SemanticKernel

Ya comprobamos que podemos usar Phi-3 en nuestro local, ahora queda armar una app con estas herramientas. Para esto vamos a crear una simple consola C# con .NET 8 e instalar el paquete NuGet de Microsoft.SemanticKernel.

dotnet add package Microsoft.SemanticKernel

📝 Paso 5: Escribir el Código para Interactuar con Phi-3

Para simplificar, aquí les dejo el código de la clase Program.cs que incluye todo lo necesario para directamente copiar, pegar y ejecutar:

#pragma warning disable SKEXP0001, SKEXP0003, SKEXP0010, SKEXP0011, SKEXP0050, SKEXP0052
using System.Text;

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;
var builder = Kernel.CreateBuilder();

builder.AddOpenAIChatCompletion(
modelId: "phi3:3.8b",
endpoint: new Uri("http://localhost:11434/"),
apiKey: "non required");

var kernel = builder.Build();

var chatService = kernel.GetRequiredService<IChatCompletionService>();

ChatHistory chatMessages = new ChatHistory([new ChatMessageContent(AuthorRole.System, "Sos un asistente de programación de C#")]);

while (true)
{
    Console.ForegroundColor = ConsoleColor.White;
    var input = Console.ReadLine();
    chatMessages.AddUserMessage(input);


    StringBuilder response = new StringBuilder();
    Console.ForegroundColor = ConsoleColor.Green;

    await foreach (var item in chatService.GetStreamingChatMessageContentsAsync(chatMessages))
    {
        response.Append(item);
        Console.Write(item.ToString());
    }

    Console.WriteLine("\n--------------------");
    chatMessages.AddAssistantMessage(response.ToString());
}

🚀 Paso 6: Ejecutar y Probar tu Proyecto de IA

Para finalizar, debemos iniciar nuestro proyecto, escribir alguna instrucción y presionar Enter. Esta prueba nos permitirá verificar el resultado final del proceso y consumir el modelo de inteligencia artificial de Phi-3.

🤯 Usar Phi-3 y Semantic Kernel con Asp .NET Core

Sabemos bien que cuando queremos desarrollar una solución de software empresarial, no lo vamos a hacer con una aplicación consola. Por eso mismo, les traigo unos pasos adicionales para poder usar Semantic Kernel en un proyecto de Asp .NET Core Minimal Api y esto mismo sirve para cualquier proyecto de Asp .NET Core.

🔨 Paso 7: Crear un Proyecto de Minimal Api e Instalar Microsoft.SemanticKernel

Creamos un nuevo proyecto Asp .NET Core Web Api y lo configuramos con las caracteristicas de Minimal Api y claramente le volvemos a instalar el mismo Nuget de Microsoft.SemanticKernel.

dotnet add package Microsoft.SemanticKernel

📝 Paso 8: Crear Clase Helper SemanticKernelExtensions.cs

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;
using Microsoft.SemanticKernel.Embeddings;
#pragma warning disable SKEXP0001, SKEXP0003, SKEXP0010, SKEXP0011, SKEXP0050, SKEXP0052


public static class SemanticKernelExtensions
{
    public static IServiceCollection AddSemanticKernel(this IServiceCollection services)
    {

        var kernel = Kernel.CreateBuilder()
            .AddOpenAIChatCompletion(
                    modelId: "phi3:3.8b",
                    endpoint: new Uri("http://localhost:11434/"),
                    apiKey: "non required")
            .Build();

        var chatService = kernel.GetRequiredService<IChatCompletionService>();

        services.AddSingleton<Kernel>(kernel);

        services.AddSingleton<IChatCompletionService>(chatService);

        return services;
    }
}

📝 Paso 9: Escribir el Código para usar Phi-3 con Semantic Kernel en una Minimal Api

Para simplificar, aquí les dejo el código de la clase Program.cs que incluye un endpoint MapPost (MinimalApi) con la inyección de dependencia de una interfaz de Semantic Kernel y permitir su ejecución desde Swagger. Esto facilitará el proceso de usar los modelo de AI como Phi-3 en nuestras soluciones de software empresariales.

using Microsoft.SemanticKernel.ChatCompletion;


var builder = WebApplication.CreateBuilder(args);

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Nuestro metodo de extensión para realizar configuraciones de SemanticKernel
builder.Services.AddSemanticKernel();



var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.MapPost("/chat", async (ChatMessage request, IChatCompletionService chatService) =>
{

    ChatHistory chatMessages = new ChatHistory();

    chatMessages.AddUserMessage(request.Message);

    var chatResponse = await chatService.GetChatMessageContentAsync(chatMessages);

    return Results.Ok(new ChatMessage(chatResponse.ToString()));
})
.WithName("Chat")
.WithOpenApi();

app.Run();

record ChatMessage(string Message);

Paso 10: Abrir Swagger y probar

Para finalizar, debemos iniciar nuestro proyecto, acceder a la página de Swagger y ejecutar nuestro endpoint para confirmar que podemos enviar un mensaje de usuario en la request que sera enviada a la AI de Phi-3 mediante Semantic Kernel y OLlama.

💥 Consideraciones 

• Las implementaciones de código, especialmente la de WebApi, se pueden usar en ambientes productivos sin problemas
• Por otro lado, esta en debate aún si OLlama es apto o no para ambientes productivos. No quieran agarrar un servidor e instalarle OLlama para usar en producción con 10 o más usuarios concurrentes. Solo sería aceptable si la cantidad de solicitudes simultáneas es controlada y limitada.
• Phi-3 es totalmente usable en producción.

🏁 Conclusión: Aprovecha el Potencial de Phi-3 en tus Aplicaciones de C#

Integrar Phi-3 con OLlama y C# en tu entorno local puede abrir un mundo de posibilidades para desarrollar aplicaciones inteligentes, automatizadas y web APIs con Semantic Kernel y Phi-3. Además, ahora podrás desarrollar aplicaciones web escalables. Con estos pasos, deberías estar listo para empezar a explorar las capacidades de Phi-3 en tus proyectos de C#. 

Si encuentras útil este trabajo y deseas mostrar tu apoyo, siempre puedes invitarme a un buen café ☕.