Compartir vía

Desarrollo de aplicaciones con Kernel semántico y Azure AI Foundry

  • Artículo

En este artículo, obtendrá información sobre cómo usar Kernel semántico con modelos implementados desde el catálogo de modelos de Azure AI en el portal de Azure AI Foundry.

Requisitos previos

  • Una suscripción de Azure.

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

  • Se ha implementado un modelo compatible con la API de inferencia del modelo de Azure AI. En este ejemplo, usamos una implementación de Mistral-Large, pero use cualquier modelo de su preferencia. Para usar funcionalidades de inserción en LlamaIndex, necesita un modelo de inserción como cohere-embed-v3-multilingual.

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

  • Kernel semántico instalado. Puede hacerlo con:

    pip install semantic-kernel

  • En este ejemplo, se trabaja con la API de inferencia del modelo de Azure AI, por lo que se instalan las dependencias de Azure adecuadas. Puede hacerlo con:

    pip install semantic-kernel[azure]

Configuración del entorno

Para usar las VM implementadas en el portal de Azure AI Foundry, necesita el punto de conexión y las credenciales para conectarse a él. Siga estos pasos para obtener la información que necesita del modelo que desea usar:

  1. Vaya al portal de Azure AI 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.

    Recorte de pantalla de la opción para copiar el URI del punto de conexión y las claves desde un punto de conexión.

    Sugerencia

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

En este escenario, colocamos la dirección URL del punto de conexión y la clave en las siguientes variables de entorno:

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

Una vez configurado, 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>")

Sugerencia

El cliente lee automáticamente las variables de entorno AZURE_AI_INFERENCE_ENDPOINT y AZURE_AI_INFERENCE_API_KEY para conectarse al modelo. Pero también puede pasar el punto de conexión y la clave directamente al cliente mediante los parámetros endpoint y api_key en el constructor.

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>")

Nota:

Al usar Microsoft Entra ID, asegúrese de que el punto de conexión se implementó con ese método de autenticación y que tiene los permisos necesarios para invocarlo.

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 se realiza la inferencia mediante la clase AzureAIInferenceChatPromptExecutionSettings:

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, se llama al servicio de finalización del chat con un historial de chat simple:

Sugerencia

Kernel semántico es una biblioteca asincrónica, por lo que debe usar la biblioteca asyncio para ejecutar el código.

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