Desarrollo de aplicaciones con kernel semántico y Microsoft Foundry

En este artículo, aprenderá a usar Semantic Kernel con modelos implementados desde el catálogo de modelos de Foundry en el portal de Microsoft Foundry.

Prerrequisitos

• Una cuenta de Azure con una suscripción activa. Si no tiene una, cree una cuenta gratuita de Azure, que incluye una suscripción de evaluación gratuita.

• Un proyecto de Foundry como se explica en Creación de un proyecto en el portal de Foundry.

• Modelo que admite la API de inferencia de modelos de Azure AI implementada. En este artículo se usa una implementación Mistral-Large. Puede usar cualquier modelo. Para usar funcionalidades de inserción en LlamaIndex, necesita un modelo de inserción como cohere-embed-v3-multilingual.

  • Puede seguir las instrucciones de Implementación de modelos como implementaciones de API sin servidor.

• Python 3.10 o una versión posterior instalado, incluido pip.

• Kernel semántico instalado. Puede usar el comando siguiente:

  pip install semantic-kernel
  

• En este artículo se usa model Inference API, por lo que se instalan las dependencias de Azure pertinentes. Puede usar el comando siguiente:

  pip install semantic-kernel[azure]
  

Configuración del entorno

Para usar modelos de lenguaje implementados en el portal de Foundry, necesita el punto de conexión y las credenciales para conectarse al proyecto. Siga estos pasos para obtener la información que necesita del modelo:

1. Inicie sesión en Microsoft Foundry.

2. Abra el proyecto donde está implementado el modelo, si aún no está abierto.

3. Vaya a Modelos y puntos de conexión y seleccione el modelo implementado como se indica en los requisitos previos.

4. Copie la dirección URL del punto de conexión y la clave.

   Sugerencia

   Si el modelo se implementó con compatibilidad con Microsoft Entra ID, no necesita una clave.

En este ejemplo se usan variables de entorno para la dirección URL del punto de conexión y la clave:

export AZURE_AI_INFERENCE_ENDPOINT="<your-model-endpoint-goes-here>"
export AZURE_AI_INFERENCE_API_KEY="<your-key-goes-here>"

Después de configurar el punto de conexión y la clave, cree un cliente para conectarse al punto de conexión:

from semantic_kernel.connectors.ai.azure_ai_inference import AzureAIInferenceChatCompletion

chat_completion_service = AzureAIInferenceChatCompletion(ai_model_id="<deployment-name>")

Como alternativa, si el punto de conexión es compatible con Microsoft Entra ID, puede usar el siguiente código para crear el cliente:

export AZURE_AI_INFERENCE_ENDPOINT="<your-model-endpoint-goes-here>"

from semantic_kernel.connectors.ai.azure_ai_inference import AzureAIInferenceChatCompletion

chat_completion_service = AzureAIInferenceChatCompletion(ai_model_id="<deployment-name>")

Modelos de Azure OpenAI

Si usa un modelo de Azure OpenAI, puede utilizar el código siguiente para crear el cliente:

from azure.ai.inference.aio import ChatCompletionsClient
from azure.identity.aio import DefaultAzureCredential

from semantic_kernel.connectors.ai.azure_ai_inference import AzureAIInferenceChatCompletion

chat_completion_service = AzureAIInferenceChatCompletion(
    ai_model_id="<deployment-name>",
    client=ChatCompletionsClient(
        endpoint=f"{str(<your-azure-open-ai-endpoint>).strip('/')}/openai/deployments/{<deployment_name>}",
        credential=DefaultAzureCredential(),
        credential_scopes=["https://cognitiveservices.azure.com/.default"],
    ),
)

Parámetros de inferencia

Puede configurar cómo realizar la inferencia mediante la AzureAIInferenceChatPromptExecutionSettings clase :

from semantic_kernel.connectors.ai.azure_ai_inference import AzureAIInferenceChatPromptExecutionSettings

execution_settings = AzureAIInferenceChatPromptExecutionSettings(
    max_tokens=100,
    temperature=0.5,
    top_p=0.9,
    # extra_parameters={...},    # model-specific parameters
)

Llamada al servicio

En primer lugar, llame al servicio de finalización del chat con un historial de chat simple:

import asyncio

async def main():
    ...

if __name__ == "__main__":
    asyncio.run(main())

from semantic_kernel.contents.chat_history import ChatHistory

chat_history = ChatHistory()
chat_history.add_user_message("Hello, how are you?")

response = await chat_completion_service.get_chat_message_content(
    chat_history=chat_history,
    settings=execution_settings,
)
print(response)

Como alternativa, puede transmitir la respuesta desde el servicio:

chat_history = ChatHistory()
chat_history.add_user_message("Hello, how are you?")

response = chat_completion_service.get_streaming_chat_message_content(
    chat_history=chat_history,
    settings=execution_settings,
)

chunks = []
async for chunk in response:
    chunks.append(chunk)
    print(chunk, end="")

full_response = sum(chunks[1:], chunks[0])

Creación de una conversación de larga duración

Puede crear una conversación de larga duración mediante un bucle :

while True:
    response = await chat_completion_service.get_chat_message_content(
        chat_history=chat_history,
        settings=execution_settings,
    )
    print(response)
    chat_history.add_message(response)
    chat_history.add_user_message(user_input = input("User:> "))

Si transmite la respuesta, puede usar el código siguiente:

while True:
    response = chat_completion_service.get_streaming_chat_message_content(
        chat_history=chat_history,
        settings=execution_settings,
    )

    chunks = []
    async for chunk in response:
        chunks.append(chunk)
        print(chunk, end="")

    full_response = sum(chunks[1:], chunks[0])
    chat_history.add_message(full_response)
    chat_history.add_user_message(user_input = input("User:> "))

Uso de modelos de inserción

Configure el entorno de forma similar a los pasos anteriores, pero use la clase AzureAIInferenceEmbeddings:

from semantic_kernel.connectors.ai.azure_ai_inference import AzureAIInferenceTextEmbedding

embedding_generation_service = AzureAIInferenceTextEmbedding(ai_model_id="<deployment-name>")

En el código siguiente se muestra cómo obtener inserciones desde el servicio:

embeddings = await embedding_generation_service.generate_embeddings(
    texts=["My favorite color is blue.", "I love to eat pizza."],
)

for embedding in embeddings:
    print(embedding)

Contenido relacionado

• Introducción a los SDK de Azure AI
• Referencia para la integración del modelo de Kernel semántico