Semantic Kernel: Framework de Agentes de Microsoft

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Qué cubre este artículo sobre Semantic Kernel

• Qué es Semantic Kernel y cómo funciona.
• Cómo construir agentes con Semantic Kernel.
• Plugins, Planners y Memory para agentes.
• Casos de uso prácticos para diferentes aplicaciones.
• Buenas prácticas para integración empresarial y producción.

Introducción: Semantic Kernel explicado

Semantic Kernel es el framework de Microsoft para agentes de IA. Conecta LLMs con plugins (herramientas), planners (orquestación) y memory (contexto). Para aplicaciones empresariales con .NET y Python.

Este artículo está dirigido a desarrolladores que desean construir agentes con Semantic Kernel. Encontrarás fundamentos en Frameworks de Agentes de IA y LangChain.

¿Por qué necesito Semantic Kernel?

Imagina que construyes un agente empresarial: debe usar tu CRM, tu ERP y tus APIs internas. Semantic Kernel ofrece integración empresarial, planners para flujos de trabajo complejos y memory para el contexto. Para el stack de Microsoft, es la opción preferida.

Semantic Kernel en resumen

Semantic Kernel = Framework de agentes de Microsoft. Plugins para herramientas, planners para orquestación, memory para contexto. Para .NET y Python, enfocado en empresas.

La idea central es: integración empresarial para agentes de IA.

¿Para quién es este artículo?

• Desarrolladores .NET que construyen agentes.
• Equipos empresariales que utilizan el stack de Microsoft.
• Desarrolladores Python que usan SK para agentes.
• DevOps que despliegan agentes en entornos empresariales.

Términos importantes

• Semantic Kernel - Framework de agentes de Microsoft. Cuándo es útil: para agentes empresariales.
• Plugin - Herramienta/integración. Cuándo es útil: para funcionalidad.
• Planner - Orquestación. Cuándo es útil: para flujos de trabajo complejos.
• Memory - Contexto. Cuándo es útil: para estado.
• Ollama - Servidor de modelos local. Cuándo es útil: para modelos locales.

Configuración

Python

pip install semantic-kernel

from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion

# Crear kernel
kernel = Kernel()

# Añadir LLM (Ollama)
kernel.add_service(OpenAIChatCompletion(
    service_id="ollama",
    ai_model_id="llama3.1",
    endpoint="http://ollama:11434/v1",
    api_key="not-needed"
))

C# / .NET

using Microsoft.SemanticKernel;

// Crear kernel
var kernel = Kernel.CreateBuilder()
    .AddOpenAIChatCompletion(
        modelId: "llama3.1",
        endpoint: new Uri("http://ollama:11434/v1"),
        apiKey: "not-needed")
    .Build();

Caso práctico 1: Crear un plugin

from semantic_kernel.functions import kernel_function

class MyPlugin:
    """Plugin personalizado para Semantic Kernel"""

    @kernel_function(
        name="get_weather",
        description="Obtener el clima"
    )
    def get_weather(self, location: str) -> str:
        """Obtener el clima para una ubicación"""
        # Llamada a API
        return f"Clima en {location}: 22°C, soleado"

    @kernel_function(
        name="send_email",
        description="Enviar correo electrónico"
    )
    def send_email(self, to: str, subject: str, body: str) -> str:
        """Enviar correo electrónico"""
        # Lógica de correo
        return f"Correo enviado a {to}"

# Añadir plugin al kernel
kernel.add_plugin(MyPlugin(), plugin_name="my_plugin")

Caso práctico 2: Planner para flujos de trabajo complejos

from semantic_kernel.planners import SequentialPlanner

# Crear planner
planner = SequentialPlanner(kernel)

# Definir objetivo
goal = "Investiga el tema, analiza los datos y escribe un informe."

# Crear plan
plan = await planner.create_plan_async(goal)

# Ejecutar plan
result = await plan.invoke_async()

Caso práctico 3: Memory para contexto

from semantic_kernel.memory import SemanticTextMemory
from semantic_kernel.connectors.ai.open_ai import OpenAITextEmbedding

# Añadir memory
memory = SemanticTextMemory(
    storage=VolatileMemoryStore(),
    embeddings_generator=OpenAITextEmbedding(
        service_id="embeddings",
        ai_model_id="text-embedding-ada-002",
        endpoint="http://ollama:11434/v1",
        api_key="not-needed"
    )
)

# Guardar información
await memory.save_information_async(
    collection="documents",
    text="El cliente Max Mustermann realizó un pedido el 15.03.",
    id="doc1"
)

# Recuperar información
results = await memory.search_async(
    collection="documents",
    query="¿Cuándo hizo Max su pedido?"
)

Caso práctico 4: Agente con plugins y memory

class SemanticKernelAgent:
    """Agente con Semantic Kernel"""

    def __init__(self):
        self.kernel = Kernel()
        self.setup_services()
        self.setup_plugins()
        self.setup_memory()

    async def run(self, task):
        """Bucle del agente"""
        # Recuperar memory (contexto)
        context = await self.memory.search_async(
            collection="context",
            query=task
        )

        # Invocar plugin o LLM directamente
        if self.needs_tool(task):
            result = await self.kernel.invoke_async(
                plugin_name="my_plugin",
                function_name="relevant_function",
                task=task,
                context=context
            )
        else:
            result = await self.llm.complete_async(task, context)

        # Guardar en memory
        await self.memory.save_information_async(
            collection="context",
            text=f"Task: {task}, Result: {result}",
            id=f"task_{datetime.now().isoformat()}"
        )

        return result

Semantic Kernel vs. LangChain

Notas de seguridad

• API Keys: Para APIs de OpenAI, usa variables de entorno para secretos, no en el código.
• Permisos de plugins: Los plugins deben verificar permisos. Ver Permisos MCP.
• Seguridad de memory: Memory puede contener datos sensibles. Almacena de forma segura.
• Auditoría: Registra todas las acciones del agente. Ver Audit Logging.

Trampa típicas

• Planners complejos: Los planners pueden crear planes complejos y difíciles de entender. Mantén simplicidad.
• Tamaño de memory: Memory puede crecer. Se necesita una estrategia de limpieza.
• Dependencias de plugins: Los plugins pueden tener dependencias externas. Documenta.
• Empresarial vs. Open Source: SK está enfocado en empresas. Para proyectos de código abierto, LangChain o CrewAI podrían ser mejores.
• .NET vs. Python: SK es más fuerte en .NET. Para solo Python, LangChain podría ser mejor.

Enlaces relacionados

• Semantic Kernel - GitHub.
• Frameworks de Agentes de IA - Descripción general.
• LangChain - Alternativa.
• CrewAI - Framework multi-agente.
• LlamaIndex - Para RAG.
• Ollama - Servidor de modelos.

Puntos clave:

• Semantic Kernel = Framework de agentes empresariales de Microsoft.
• Plugins para herramientas, planners para orquestación, memory para contexto.
• Para .NET y Python, enfocado en empresas.
• Para el stack de Microsoft y aplicaciones empresariales.
• Para proyectos de código abierto, LangChain o CrewAI podrían ser mejores.

FAQ

Fuentes y lecturas adicionales

• Semantic Kernel - GitHub.
• Semantic Kernel Docs - Documentación.
• Microsoft Copilot - Integración de Copilot.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert