Skip to content

Home

What is concierge?

concierge is a Python hands-on repository for building LLM applications on Microsoft Foundry using LangChain and LangGraph. It ships with two complementary surfaces:

Surface Runs entirely local? What you learn
Todo App (Clean Architecture) yes A small FastAPI + Typer + clean-architecture reference
Hands-on Tutorial partly Foundry chat / embeddings, observability, pgvector, a LangGraph agent

Service modules & dependencies

The Python source under concierge/ is split into small per-feature packages. Each one follows the same clean-architecture layout (domain / application / infrastructure) and is wired together through a shared concierge.settings configuration layer.

Package Role Surfaces Depends on (concierge)
settings Pydantic-Settings config with per-service namespaces (Foundry, Postgres, observability, ...) — —
loggers, observability Shared logging + Foundry / Azure Monitor / MLflow tracing helpers — settings
todo Task CRUD reference application REST API, CLI settings
knowledge Markdown ingest + pgvector RAG store CLI settings
agents Shared agent runtime — AgentRegistry, adapters (Echo / GitHub Copilot SDK / LangGraph / Microsoft Agent Framework) and built-in tools (echo, file management, shell command, image generation) CLI settings
chat Chat conversations and replies (synchronous + realtime voice) REST API, CLI, Realtime settings, agents (optional, agent-backed responder)
cloud_agent Async task dispatcher that runs agent jobs through a queue + repository REST API, CLI settings, agents

The dependency direction is strictly one-way:

  • agents, todo, and knowledge are independent bounded contexts — nothing in them imports another service package.
  • chat and cloud_agent are the only services that import agents, and they do so at the infrastructure / application boundary, never from their domain layer.
  • These rules are enforced in CI by import-linter contracts declared in pyproject.toml (run locally with make lint-imports).
flowchart LR
    settings[settings]
    obs["loggers / observability"]
    agents[agents]
    todo[todo]
    knowledge[knowledge]
    chat[chat]
    cloud_agent[cloud_agent]

    obs --> settings
    todo --> settings
    knowledge --> settings
    agents --> settings
    chat --> settings
    cloud_agent --> settings

    chat --> agents
    cloud_agent --> agents

Note

The tutorial CLI scripts/langgraph/vanilla.py drives the Todo app over the public REST API via httpx — it does not import concierge.todo directly. Treat that as a runtime integration only.

Where do I start?

Pick the closest match to your goal. Each path links forward into the next so you can keep going as far as you want.

Start with the Todo App overview. It boots with one command (uv run todo-web), needs no Azure credentials, and shows how the FastAPI / Typer / repository layers fit together.

Jump to Step 1 - Microsoft Foundry + LangChain. You will run a chat completion against your Foundry project from a Typer CLI in under five minutes.

Read Step 2 - Observability (Tracing & MLflow). It shows how to send LangChain runs to Azure Monitor and how to view them locally in the MLflow UI - screenshots included.

Read Monitor VS Code Copilot via App Insights. A bundled OTel Collector forwards Copilot Chat operations, tokens, tool calls, and per-model latency to Azure Application Insights — queryable from the portal and the prebuilt Grafana dashboard at aka.ms/amg/dash/gh-copilot.

Read Step 3 - PostgreSQL (pgvector) CRUD. One Typer CLI runs against either Docker Compose pgvector or Azure Database for PostgreSQL Flexible Server.

Read Step 4 - LangGraph Todo Agent CLI. The LangGraph agent talks to the Todo Web API through tools and combines everything from steps 1-3.

Quick reference