Microsoft Azure Cosmos DB AI Developer

Distributed data forces a choice between freshness, speed and availability. You learn the consistency levels, what each promises a reader, and how to set and override them per request.

• Strong, bounded staleness, session, consistent prefix and eventual
• What each level promises a reader
• Latency, availability and cost effects
• Session tokens in distributed applications
• Overriding consistency per request
• Choosing a level from application requirements

You build A consistency recommendation for three scenarios, each justified by its read and write behavior.

Cosmos DB rewards models built around access patterns. You decide when to embed related data and when to reference it, denormalize for reads, and keep copies in step.

• Access patterns first
• Embedding compared with referencing
• Denormalization and keeping copies consistent
• Item size, shape and the document model
• Modeling one-to-many and many-to-many
• Evolving a model over time

You build A data model for a conversational application, with its access patterns written down.

The partition key decides scale, cost and the queries you can afford. You choose keys that spread load, use hierarchical partition keys, and recognize hot partitions and cross-partition queries before they hurt.

• Logical and physical partitions
• Choosing a partition key
• Hierarchical partition keys
• Hot partitions and how to spot them
• Cross-partition queries and their cost
• Changing a partition key later

You build A partition key design tested with generated data and checked for skew.

Efficient operations are the difference between a cheap workload and an expensive one. You write queries, prefer point reads, patch items in place, and group writes in transactional batches and bulk operations.

• SDK setup in C# and Python
• Point reads compared with queries
• The SQL query language over JSON items
• Partial updates with patch
• Transactional batch and bulk execution
• Handling throttling, retries and conflicts
• Optimistic concurrency with ETags

You build A data access layer with point reads, patches and batch writes that handles throttling.

The change feed turns a database into an event source. You read it with the SDK and with Azure Functions, handle ordering, and design downstream views, search indexes and notifications.

• How the change feed works and what it includes
• The change feed processor
• The Azure Functions trigger for Cosmos DB
• Ordering, checkpoints and replays
• Materialized views and aggregation
• Handling deletes

You build A change feed processor that keeps a second container in step with a source container.

A database account is a high-value target. You replace keys with Entra identities and data-plane roles, restrict network paths, and protect data with encryption options.

• Keys compared with Microsoft Entra ID access
• Data-plane role-based access control
• Managed identities for applications
• Firewalls, virtual networks and private endpoints
• Encryption and customer-managed keys
• Auditing and diagnostics

You build A Cosmos DB account with key access disabled, identity-based roles and private networking.

Cosmos DB can span regions, but only if you design for it. You configure replication and failover, choose backup modes, and plan restores for the failures that actually occur.

• Multi-region reads and writes
• Service-managed and manual failover
• Availability zones
• Continuous and periodic backup
• Point-in-time restore
• Conflict resolution in multi-write accounts

You build A two-region account with a rehearsed failover and a point-in-time restore.

Query cost is visible if you know where to look. You read query metrics and request charges, tune indexing policies, and use caching and design changes to reach latency targets.

• Indexing policies, paths and index types
• Reading query metrics and request charge
• Composite indexes for sorting and filtering
• Integrated cache and dedicated gateway
• Reducing cross-partition work
• Load testing against latency targets

You build A tuning report that lowers the request charge of three queries, with the policy changes behind it.

Production estates have many accounts and teams. You apply governance, monitoring and cost controls across accounts, and keep configuration consistent as the fleet grows.

• Account inventory and standards
• Monitoring across accounts
• Cost allocation and throughput planning
• Deploying accounts as code
• Policy and governance at fleet scale
• Planning maintenance and upgrades

You build An infrastructure-as-code template for a standard account, with monitoring and policy applied.

Retrieval is where AI applications meet the database. You store embeddings, build vector and full-text indexes, combine them in hybrid queries, and use the results to ground a language model.

• Embeddings stored beside operational data
• Vector indexes and distance functions
• Full-text search in Cosmos DB
• Hybrid search and rank fusion
• Filtering and partition-aware retrieval
• Feeding retrieved items to a RAG pipeline
• Measuring retrieval quality

You build A RAG back end on Cosmos DB with vector and hybrid retrieval, measured against test questions.

Agents that remember are more useful, and memory is a data problem. You design stores for short-term and long-term memory, keep them scoped per user and per agent, and retrieve what matters.

• What an agent needs to remember
• Short-term, long-term and shared memory models
• Scoping memory by user, agent and session
• Summarizing and expiring memory with TTL
• Retrieving memory with vectors and filters
• Agent tooling that builds on Cosmos DB
• Privacy, deletion and audit of memory

You build A memory store for an agent that scopes, expires and retrieves memory per user.

Analytics should not slow transactions. You mirror Cosmos DB data into Microsoft Fabric, query it for reporting, and decide what to mirror and what to keep out.

• Why separate analytics from operations
• Setting up mirroring into Fabric
• Querying mirrored data with SQL
• Schema and data type behavior in mirroring
• Cost and latency of mirrored data
• Choosing between mirroring and the change feed

You build A mirrored container queried from Fabric for a business report.

Build one data layer for an AI application. You model and partition the data, secure and replicate it, add retrieval and memory, and prove it meets latency and cost targets.

• Modeling and partitioning from access patterns
• Securing and replicating the account
• Adding retrieval and agent memory
• Adding analytics through mirroring
• Measuring against targets and tuning

You build A Cosmos DB back end with retrieval, agent memory, analytics and measured latency and cost.