Semantic Kernel: Microsofts Agenten-Framework

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Semantic Kernel behandelt

• Was Semantic Kernel ist und wie es funktioniert.
• Wie Du Agenten mit Semantic Kernel baust.
• Plugins, Planner und Memory für Agenten.
• Praxisbeispiele für verschiedene Anwendungsfälle.
• Best Practices für Enterprise-Integration und Produktion.

Einleitung: Semantic Kernel verständlich erklärt

Semantic Kernel ist Microsofts Framework für KI-Agenten. Es verbindet LLMs mit Plugins (Tools), Plannern (Orchestrierung) und Memory (Kontext). Für Enterprise-Anwendungen mit .NET und Python.

Dieser Artikel richtet sich an Entwickler, die Agenten mit Semantic Kernel bauen wollen. Grundlagen findest Du in KI-Agenten-Frameworks und LangChain.

Warum brauche ich Semantic Kernel?

Stell Dir vor, Du baust einen Enterprise-Agenten: Er soll Dein CRM, Dein ERP und Deine internen APIs nutzen. Semantic Kernel bietet Enterprise-Integration, Planner für komplexe Workflows und Memory für Kontext. Für Microsoft-Stack ist es die erste Wahl.

Semantic Kernel kurz erklärt

Semantic Kernel = Microsofts Agenten-Framework. Plugins für Tools, Planner für Orchestrierung, Memory für Kontext. Für .NET und Python, Enterprise-fokussiert.

Der Kerngedanke lautet: Enterprise-Integration für KI-Agenten.

Für wen ist dieser Artikel gedacht?

• .NET-Entwickler, die Agenten bauen.
• Enterprise-Teams, die Microsoft-Stack nutzen.
• Python-Entwickler, die SK für Agenten nutzen.
• DevOps, die Agenten in Enterprise-Umgebungen deployen.

Wichtige Begriffe

• Semantic Kernel - Microsofts Agenten-Framework. Wann nützlich: für Enterprise-Agenten.
• Plugin - Tool/Integration. Wann nützlich: für Funktionalität.
• Planner - Orchestrierung. Wann nützlich: für komplexe Workflows.
• Memory - Kontext. Wann nützlich: für Zustand.
• Ollama - Lokaler Modellserver. Wann nützlich: für lokale Modelle.

Setup

Python

pip install semantic-kernel

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

# Kernel erstellen
kernel = Kernel()

# LLM hinzufügen (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;

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

Praxisbeispiel 1: Plugin erstellen

from semantic_kernel.functions import kernel_function

class MyPlugin:
    """Custom Plugin für Semantic Kernel"""

    @kernel_function(
        name="get_weather",
        description="Wetter abrufen"
    )
    def get_weather(self, location: str) -> str:
        """Wetter für einen Ort abrufen"""
        # API-Aufruf
        return f"Wetter in {location}: 22°C, sonnig"

    @kernel_function(
        name="send_email",
        description="E-Mail senden"
    )
    def send_email(self, to: str, subject: str, body: str) -> str:
        """E-Mail senden"""
        # E-Mail-Logik
        return f"E-Mail an {to} gesendet"

# Plugin zum Kernel hinzufügen
kernel.add_plugin(MyPlugin(), plugin_name="my_plugin")

Praxisbeispiel 2: Planner für komplexe Workflows

from semantic_kernel.planners import SequentialPlanner

# Planner erstellen
planner = SequentialPlanner(kernel)

# Ziel definieren
goal = "Recherchiere das Thema, analysiere die Daten und schreibe einen Bericht."

# Plan erstellen
plan = await planner.create_plan_async(goal)

# Plan ausführen
result = await plan.invoke_async()

Praxisbeispiel 3: Memory für Kontext

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

# Memory hinzufügen
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"
    )
)

# Informationen speichern
await memory.save_information_async(
    collection="documents",
    text="Der Kunde Max Mustermann hat am 15.03. bestellt.",
    id="doc1"
)

# Informationen abrufen
results = await memory.search_async(
    collection="documents",
    query="Wann hat Max bestellt?"
)

Praxisbeispiel 4: Agent mit Plugins und Memory

class SemanticKernelAgent:
    """Agent mit Semantic Kernel"""

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

    async def run(self, task):
        """Agent-Loop"""
        # Memory abrufen (Kontext)
        context = await self.memory.search_async(
            collection="context",
            query=task
        )

        # Plugin aufrufen oder LLM direkt
        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)

        # Memory speichern
        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

Sicherheitshinweise

• API-Keys: Für OpenAI-APIs: Secrets als Env-Vars, nicht im Code.
• Plugin-Berechtigungen: Plugins sollten Berechtigungen prüfen. Siehe MCP-Berechtigungen.
• Memory-Sicherheit: Memory kann sensible Daten enthalten. Sicher speichern.
• Audit: Alle Agenten-Aktionen loggen. Siehe Audit Logging.

Typische Stolpersteine

• Komplexe Planner: Planner können komplexe, schwer verständliche Pläne erstellen. Einfach halten.
• Memory-Größe: Memory kann groß werden. Cleanup-Strategie nötig.
• Plugin-Abhängigkeiten: Plugins können externe Abhängigkeiten haben. Dokumentieren.
• Enterprise vs. Open Source: SK ist Enterprise-fokussiert. Für Open-Source-Projekte: LangChain oder CrewAI.
• .NET vs. Python: SK ist stärker in .NET. Für Python-Only: LangChain könnte besser sein.

Weiterführende Links

• Semantic Kernel - GitHub.
• KI-Agenten-Frameworks - Übersicht.
• LangChain - Alternative.
• CrewAI - Multi-Agent-Framework.
• LlamaIndex - Für RAG.
• Ollama - Modellserver.

Key Takeaways:

• Semantic Kernel = Microsofts Enterprise-Agenten-Framework.
• Plugins für Tools, Planner für Orchestrierung, Memory für Kontext.
• Für .NET und Python, Enterprise-fokussiert.
• Für Microsoft-Stack und Enterprise-Anwendungen.
• Für Open-Source-Projekte: LangChain oder CrewAI könnten besser sein.

FAQ

Quellen und weiterführende Literatur

• Semantic Kernel - GitHub.
• Semantic Kernel Docs - Dokumentation.
• Microsoft Copilot - Copilot-Integration.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert