Självstudie: Skapa en agentisk webbapp i Azure App Service med LangGraph eller Foundry Agent Service (Python)

Den här handledningen visar hur du lägger till agentbaserad funktionalitet i en befintlig datadriven FastAPI CRUD-applikation. Det gör detta med två olika metoder: LangGraph och Foundry Agent Service.

Om ditt webbprogram redan har användbara funktioner, till exempel shopping, hotellbokning eller datahantering, är det relativt enkelt att lägga till agentfunktioner i webbappen genom att omsluta funktionerna i ett plugin-program (för LangGraph) eller som en OpenAPI-slutpunkt (för Foundry Agent Service). I den här handledningen börjar du med en enkel app för att göra-listor. I slutet kan du skapa, uppdatera och hantera uppgifter med en agent i en App Service-app.

Med både LangGraph och Foundry Agent Service kan du skapa agentiska webbprogram med AI-drivna funktioner. LangGraph liknar Microsoft Agent Framework och är ett SDK. Följande tabell visar några av övervägandena och kompromisserna:

I den här tutorialen lär du dig följande:

Förutsättningar

• Ett Azure-konto med en aktiv prenumeration – Skapa ett konto kostnadsfritt.
• GitHub-konto för att använda GitHub Codespaces – Läs mer om GitHub Codespaces.

Öppna exemplet med Codespaces

Det enklaste sättet att komma igång är att använda GitHub Codespaces, som ger en fullständig utvecklingsmiljö med alla nödvändiga verktyg förinstallerade.

1. Navigera till GitHub-lagringsplatsen på https://github.com/Azure-Samples/app-service-agentic-langgraph-foundry-python.

2. Välj knappen Kod , välj fliken Codespaces och välj Skapa kodområde på main.

3. Vänta några ögonblick medan din Codespace initialiseras. När du är klar visas en fullständigt konfigurerad utvecklingsmiljö i webbläsaren.

4. Kör programmet lokalt:

   python3 -m venv venv
   source venv/bin/activate
   pip install -r requirements.txt
   uvicorn src.app:app --host 0.0.0.0 --port 3000
   

5. När du ser Din app som körs på port 3000 är tillgänglig, väljer du Öppna i webbläsare och lägger till några uppgifter.

   Agenterna är inte helt konfigurerade så de fungerar inte än. Du konfigurerar dem senare.

Granska agentkoden

Båda metoderna använder samma implementeringsmönster, där agenten initieras vid programstart, och svarar på användarmeddelanden via POST-begäranden.

self.memory = InMemorySaver()
# App Service authentication protects this sample, which intentionally
# keeps one server-managed conversation thread per worker process.
self.thread_id = "authenticated-conversation"

try:
    endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
    deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME")
    
    if not endpoint or not deployment_name:
        print("Azure OpenAI configuration missing for LangGraph agent")
        return
    
    # Initialize Azure OpenAI client
    credential = DefaultAzureCredential()
    azure_ad_token_provider = get_bearer_token_provider(
        credential, "https://cognitiveservices.azure.com/.default"
    )
    
    self.llm = AzureChatOpenAI(
        azure_endpoint=endpoint,
        azure_deployment=deployment_name,
        azure_ad_token_provider=azure_ad_token_provider,
        api_version="2024-10-21"
    )
    
    # Define tools
    tools = [
        self._create_task_tool(),
        self._get_tasks_tool(),
        self._get_task_tool(),
        self._update_task_tool(),
        self._delete_task_tool()
    ]
    
    # Create the agent
    self.agent = create_react_agent(self.llm, tools, checkpointer=self.memory)

config = {"configurable": {"thread_id": self.thread_id}}

# Process the message
result = await self.agent.ainvoke(
    {"messages": [("user", message)]},
    config=config
)

# Create the project client using Azure credentials
self.project_client = AIProjectClient(
    endpoint=endpoint,
    credential=DefaultAzureCredential()
)

# Get the OpenAI client for conversation operations
self.openai_client = self.project_client.get_openai_client()

# Find the existing agent by name
self.agent = self.project_client.agents.get(agent_name)

if not self.agent:
    print(f"Agent with name '{agent_name}' not found in project.")
    return
            
# App Service authentication protects this sample, which intentionally
# keeps one server-managed conversation per worker process.
conversation = self.openai_client.conversations.create()
self.conversation_id = conversation.id

@router.get(
    "/tasks",
    response_model=List[TaskItem],
    operation_id="getAllTasks",
    description="Retrieve all tasks in the task list."
)
async def get_all_tasks():
    """Get all tasks"""
    try:
        tasks = await task_service.get_all_tasks()
        return tasks
    except Exception as e:
        print(f"Error getting tasks: {e}")
        import traceback
        traceback.print_exc()
        raise HTTPException(status_code=500, detail=f"Failed to get tasks: {str(e)}")

# Add user message to the conversation
await asyncio.to_thread(
    self.openai_client.conversations.items.create,
    conversation_id=self.conversation_id,
    items=[{"type": "message", "role": "user", "content": message}],
)

# Create response using the agent
response = await asyncio.to_thread(
    self.openai_client.responses.create,
    conversation=self.conversation_id,
    extra_body={"agent": {"name": self.agent.name, "type": "agent_reference"}},
    input="",
)

Distribuera exempelprogrammet

Exempelarkivet innehåller en Azure Developer CLI (AZD)-mall, som skapar en App Service-app och distribuerar din exempelapplikation. Den av App Service systemtilldelade hanterade identiteten behålls för utgående Azure AI-anrop. En separat användartilldelad hanterad identitet och federerad identitetslegitimation gör att App Service-autentisering kan fungera som den genererade Microsoft Entra-applikationen utan klienthemlighet.

1. I terminalen, logga in på Azure genom att använda Azure Developer CLI:

   azd auth login
   

   Följ anvisningarna för att slutföra autentiseringsprocessen.

2. Distribuera Azure App Service-appen genom att använda AZD-mallen:

   azd up
   

3. När du uppmanas att ge följande svar:

   Question	Svar
   Ange ett nytt miljönamn:	Skriv ett unikt namn.
   Välj en Azure-prenumeration som ska användas:	Välj prenumerationen.
   Välj en resursgrupp som ska användas:	Välj Skapa en ny resursgrupp.
   Välj en plats för att skapa resursgruppen i:	Välj Sweden Central.
   Ange ett namn för den nya resursgruppen:	Skriv Retur.

4. I AZD-utdata letar du reda på url:en för din app och navigerar till den i webbläsaren. Kopiera också värdet för Foundry OpenAPI managed identity audience för att använda senare. Utdata ser ut så här:

    Deploying services (azd deploy)
   
      (✓) Done: Deploying service web
      - Endpoint: <URL>
   
    Foundry OpenAPI managed identity audience:
        api://<generated-client-id>
    

5. När Microsoft uppmanar dig loggar du in med ett konto i distributionsklientorganisationen och verifierar att uppgiftslistan läses in.

6. I samma autentiserade webbläsare lägger du till /openapi.json i slutet av App Service-slutpunkten. Kopiera eller spara det genererade OpenAPI-schemat för senare.

   Anmärkning

   App Service-autentisering returnerar en HTTP 302-omdirigering för oautentiserade webbläsarförfrågningar. Detta exempel innehåller både ett webbläsargränssnitt och API:er, så omdirigeringen ger en användbar inloggningsupplevelse. API-endast appar använder vanligtvis HTTP 401 istället.

Skapa och konfigurera Microsoft Foundry-resursen

Tilldela nödvändiga behörigheter

Konfigurera anslutningsvariabler i exempelprogrammet

1. Öppna .env. Med de värden som du kopierade tidigare från Foundry-portalen konfigurerar du följande variabler:

   • LangGraph
   • Gjuteriagenttjänst

   Variable	Description
   AZURE_OPENAI_ENDPOINT	Azure OpenAI endpoint (kopierat från Foundry-portalens startsida).
   AZURE_OPENAI_DEPLOYMENT_NAME	Modellnamn i distributionen (kopieras från modelllekplatsen i den nya Foundry-portalen).

   Anmärkning

   För att hålla självstudien enkel kommer du att använda dessa variabler i .env i stället för att skriva över dem genom att använda appinställningar i App Service.

   Anmärkning

   För att hålla självstudien enkel kommer du att använda dessa variabler i .env i stället för att skriva över dem genom att använda appinställningar i App Service.

   Värdena i .env konfigurerar appens utgående anslutning till Foundry. AZURE_AI_FOUNDRY_ACCOUNT_CLIENT_ID konfigurerar den separata inkommande Foundry-to-App-Service OpenAPI-anslutningen och lagras i AZD-miljön.

2. Logga in på Azure med Azure CLI:

   az login
   

   På så sätt kan Azure Identity-klientbiblioteket i exempelkoden ta emot en autentiseringstoken för den inloggade användaren. Kom ihåg att du lade till den roll som krävs för den här användaren tidigare.

3. Kör programmet lokalt:

   source venv/bin/activate
   uvicorn src.app:app --host 0.0.0.0 --port 3000
   

4. När du ser Programmet som körs på port 3000 är tillgängligt, väljer du Öppna i webbläsare.

5. Validera båda pivoterna separat:

   • LangGraph: Välj LangGraph Agent och be agenten skapa en uppgift. LangGraph anropar det pågående uppgiftsverktyget.
   • Gjuteriagenttjänst: Välj Foundry Agent och be agenten skapa en uppgift. Den fjärrstyrda Foundry-agenten anropar den distribuerade, skyddade /api/tasks endpointen med hanterad identitet.

   Uppgiften som Foundry-agenten skapar visas i den distribuerade App Service-instansen, inte i den lokala SQLite-databasen. Foundry OpenAPI-verktyget använder alltid serverns URL inbäddad i OpenAPI-schemat.

6. Tillbaka i GitHub-kodområdet distribuerar du dina appändringar.

   azd up
   

7. Gå till den distribuerade applikationen igen och testa båda chattagenterna. Webbläsaren skickar endast meddelandetext; den skickar inte ett sessions-ID eller konversations-ID för någon av agenterna.

Vanliga frågor och svar

• Hur lägger jag till återkallande förstärkt generering (RAG) till Foundry-agenten?

Hur lägger jag till sökningsförstärkt generering (RAG) i Foundry-agenten?

Denna vägledning gäller för Foundry Agent Service-vägen i denna handledning. Det ändrar inte de implementationer av LangGraph, Semantic Kernel eller Microsoft Agent Framework som visas i den andra fliken.

Skapa eller välj en kunskapsbas för Foundry IQ, och koppla sedan kunskapsbasen till Foundry Agent Service-agenten. Kopplingen exponeras för agenten som ett hanterat MCP-kunskapsverktyg.

App Service-koden fortsätter att anropa samma agent vid namn via sin befintliga Foundry-klient och agent_reference. Webbappen behöver inte en direkt Azure AI-sökning-integration eller en egen MCP-klient. Om användargränssnittet visar källor, bearbeta citeringsanteckningarna som agenten returnerat.

Rensa resurser

När du är klar med programmet kan du ta bort App Service-resurserna för att undvika ytterligare kostnader:

azd down --purge

AZD-hooken postdown tar också bort Microsoft Entra-applikationen på klientorganisationsnivå som har skapats för App Service-autentisering.

Ta sedan bort Foundry-resursen om du skapade den separat.

Fler resurser

• Integrera AI i dina Azure App Service-program
• Vad är Foundry Agent Service?
• LangGraph – snabbstart
• Azure AI Projects-klientbibliotek för Python