deployment-state.json<\/code>, so later steps do not rely on chat history.<\/p>\nFor long-running Azure operations, poll status with concise output. Do not repeatedly dump full JSON unless troubleshooting requires it.<\/p>\n
When a step fails, diagnose the smallest failing unit first, capture the exact error, and continue only after confirming the fix.<\/p>\n
Prefer deterministic scripts over one-off terminal commands when a step may need to be rerun.<\/p>\n
Do not report completion until the final validation checklist passes.<\/p>\n
Important constraints<\/p>\n
1. Use Azure CLI or Azure Developer CLI where appropriate.\n2. Prefer Azure CLI for explicit, auditable commands.\n3. Create a new Resource Group.\n4. Use Azure SQL Database free offer if available in this subscription and region.\n5. Assume the Azure SQL Database free offer may require Azure portal creation.\n6. Before creating a paid SQL database, check whether the free offer can be created through the current Azure CLI. If it cannot, stop and output the exact portal instruction for creating the free database manually. Do not treat this as a failure. Treat it as the expected safe path when the free offer is portal-only.\n7. Do not silently create a paid SQL database unless explicitly confirmed.\n8. Use the lowest cost App Service plan that supports the required runtime and startup command. Prefer Free F1 if it supports this scenario. If F1 does not support the required runtime or startup command reliably, use Basic B1 and clearly explain why.\n9. Deploy as code to Azure App Service. Do not deploy a container.\n10. Install Data API builder using dotnet tool install microsoft.dataapibuilder –prerelease.\n11. Use a local .NET tool manifest for DAB in the deployed App Service content.\n12. Create a working SQL table named dbo.products.\n13. Add the DAB entity named products.\n14. Enable MCP, REST, and GraphQL.\n15. Use AppService authentication provider for HTTP mode.\n16. Use Simulator authentication provider only for STDIO local testing.\n17. Store the SQL connection string in an environment variable or App Service setting named SQL_CONNECTION_STRING.\n18. Do not hardcode secrets into dab-config.json.\n19. Explicitly verify that dab-config.json uses @env(‘SQL_CONNECTION_STRING’) before deployment.\n20. Do not print full connection strings, client secrets, SQL admin passwords, or access tokens. When logging values, redact secrets and show only resource names, server names, database names, and endpoint URLs.\n21. Produce all final files and a README.md.\n22. Verify local endpoints before deployment.\n23. Verify Azure endpoints after deployment.\n24. Include cleanup commands at the end.\n25. Configure App Service CORS only if testing from a browser-based MCP or agent client requires it. Do not use wildcard CORS unless clearly marked as temporary demo configuration.\n26. Do not report success until App Service logs show DAB started successfully, and REST, GraphQL, and MCP paths are reachable.<\/p>\n
Reference documentation<\/p>\n
Use these Microsoft Learn and sample repository references while implementing. Prefer these sources over guessing command syntax or behavior.<\/p>\n
SQL MCP Server:\nhttps:\/\/learn.microsoft.com\/en-us\/azure\/data-api-builder\/mcp\/<\/p>\n
Data API builder deployment options:\nhttps:\/\/learn.microsoft.com\/en-us\/azure\/data-api-builder\/deployment\/<\/p>\n
Data API builder CLI reference:\nhttps:\/\/learn.microsoft.com\/en-us\/azure\/data-api-builder\/command-line\/<\/p>\n
Install the DAB CLI:\nhttps:\/\/learn.microsoft.com\/en-us\/azure\/data-api-builder\/command-line\/install<\/p>\n
Initialize a DAB config:\nhttps:\/\/learn.microsoft.com\/en-us\/azure\/data-api-builder\/command-line\/dab-init<\/p>\n
Configure DAB runtime and data source:\nhttps:\/\/learn.microsoft.com\/en-us\/azure\/data-api-builder\/command-line\/dab-configure<\/p>\n
Azure App Service authentication for MCP servers:\nhttps:\/\/learn.microsoft.com\/en-us\/azure\/app-service\/configure-authentication-mcp<\/p>\n
Azure App Service ZIP deployment:\nhttps:\/\/learn.microsoft.com\/en-us\/azure\/app-service\/deploy-zip<\/p>\n
Azure SQL Database free offer:\nhttps:\/\/learn.microsoft.com\/en-us\/azure\/azure-sql\/database\/free-offer<\/p>\n
Azure sample repository:\nhttps:\/\/github.com\/Azure-Samples\/SQL-MCP-NoContainer<\/p>\n
Setup walkthrough:\nhttps:\/\/github.com\/Azure-Samples\/SQL-MCP-NoContainer\/blob\/main\/How-to-setup-DAB.md<\/p>\n
Run MCP walkthrough:\nhttps:\/\/github.com\/Azure-Samples\/SQL-MCP-NoContainer\/blob\/main\/How-to-Run-MCP.md<\/p>\n
Assumptions<\/p>\n
Use PowerShell syntax for commands unless the current shell is not PowerShell. If the terminal is bash, translate commands safely.<\/p>\n
When uncertain about syntax or behavior, consult the reference documentation above first, then inspect local CLI help such as az –help, az webapp –help, and dab –help.<\/p>\n
Use these default names unless a conflict requires unique suffixes:<\/p>\n
Resource group prefix: rg-sql-mcp-appservice\nLocation: eastus\nSQL logical server prefix: sqlmcp\nSQL database name: sqldb-sqlmcp-free\nSQL admin login: sqlmcpadmin\nProduct table: dbo.products\nApp Service plan prefix: asp-sql-mcp\nWeb app prefix: app-sql-mcp\nProject folder: sql-mcp-appservice<\/p>\n
Use a random short suffix for globally unique Azure resources.<\/p>\n
Required local project output<\/p>\n
Create a local folder with at least:<\/p>\n
README.md\ndab-config.json\nschema.sql\nseed.sql\ndeploy.ps1\ntest-local.ps1\ntest-azure.ps1\ncleanup.ps1\nstartup.sh for Linux App Service if Linux is used\nstartup.cmd for Windows App Service if Windows is used\n.config\/dotnet-tools.json\npackage or deployment files required for App Service code deployment<\/p>\n
Implementation steps<\/p>\n
Step 1: Inspect prerequisites<\/p>\n
Check whether these are installed:<\/p>\n
az\ndotnet\nPowerShell\nzip support\nDAB CLI\nsqlcmd or another Microsoft-supported SQL execution tool\nPython, only as ZIP fallback<\/p>\n
If Azure CLI is not logged in, run az login.<\/p>\n
Show the active subscription:<\/p>\n
az account show<\/p>\n
Ask for no interactive decisions unless absolutely required. If multiple subscriptions exist, use the active subscription and document it.<\/p>\n
Step 2: Create names and variables<\/p>\n
Generate a unique suffix.<\/p>\n
Set variables for:<\/p>\n
RESOURCE_GROUP\nLOCATION\nSQL_SERVER\nSQL_DB\nSQL_ADMIN_USER\nSQL_ADMIN_PASSWORD\nAPP_SERVICE_PLAN\nWEB_APP\nSQL_CONNECTION_STRING<\/p>\n
Generate a strong SQL admin password locally. Do not print the full password. Store it in script variables only.<\/p>\n
Step 3: Create Azure Resource Group<\/p>\n
Create a new Resource Group:<\/p>\n
az group create –name $RESOURCE_GROUP –location $LOCATION<\/p>\n
Step 4: Create Azure SQL Database using the free offer if possible<\/p>\n
First, investigate current Azure CLI support for creating an Azure SQL Database free offer.<\/p>\n
Use official az help and command discovery:<\/p>\n
az sql db create –help\naz sql db list-editions -l $LOCATION -o table<\/p>\n
Try to identify whether a free offer parameter exists. If a supported CLI parameter exists, use it.<\/p>\n
If the Azure SQL Database free offer cannot be applied through CLI in this environment, stop before creating a paid database and output this required portal instruction:<\/p>\n
\u201cCreate the Azure SQL Database from the Azure portal using Start free \/ Free offer applied, in the Resource Group named <RESOURCE_GROUP>, with database name <SQL_DB>. Choose the behavior that auto-pauses the database when the free monthly limit is reached. After creating the database, rerun this prompt or continue from Step 5.\u201d<\/p>\n
Do not create a paid SQL database as a fallback unless explicitly told.<\/p>\n
If a free SQL database can be created through CLI, create it. Requirements:<\/p>\n
Serverless General Purpose\nFree offer applied\nAuto-pause when free limit reached, where configurable\nMaximum size within free offer limits\nLowest cost settings<\/p>\n
Step 5: Create SQL logical server and configure access<\/p>\n
If not already created by the free offer flow, create the SQL logical server.<\/p>\n
Configure Microsoft Entra admin if possible using the current signed-in user. Also configure SQL admin credentials as fallback only for setup.<\/p>\n
Add firewall access for the current client IP so setup scripts can connect.<\/p>\n
If possible, also allow Azure services to access the server only if needed for App Service connectivity. Prefer the narrowest access compatible with the walkthrough.<\/p>\n
Step 6: Create schema and seed data<\/p>\n
Create schema.sql:<\/p>\n
CREATE TABLE dbo.products\n(\nProductID int IDENTITY(1,1) NOT NULL CONSTRAINT PK_products PRIMARY KEY,\nName nvarchar(100) NOT NULL,\nCategory nvarchar(100) NOT NULL,\nPrice decimal(10,2) NOT NULL,\nInStock bit NOT NULL CONSTRAINT DF_products_InStock DEFAULT (1),\nCreatedAt datetime2 NOT NULL CONSTRAINT DF_products_CreatedAt DEFAULT (sysutcdatetime())\n);<\/p>\n
Create seed.sql:<\/p>\n
INSERT INTO dbo.products (Name, Category, Price, InStock)\nVALUES\n(N’Road Bike’, N’Cycling’, 1299.99, 1),\n(N’Mountain Bike’, N’Cycling’, 1499.99, 1),\n(N’Helmet’, N’Accessories’, 79.99, 1),\n(N’Water Bottle’, N’Accessories’, 12.99, 1),\n(N’Bike Light’, N’Accessories’, 24.99, 0);<\/p>\n
Apply schema and seed using sqlcmd if available. If sqlcmd is missing, install it or use an available SQL execution method. Prefer a Microsoft-supported tool. Verify the table exists and rows are present.<\/p>\n
Step 7: Create Microsoft Entra app registration and service principal for database access<\/p>\n
Create an app registration and service principal for SQL MCP Server database access.<\/p>\n
Capture:<\/p>\n
APPLICATION_CLIENT_ID\nTENANT_ID\nCLIENT_SECRET<\/p>\n
Create a client secret. Do not print the full secret.<\/p>\n
Grant the service principal access inside Azure SQL Database.<\/p>\n
Use T-SQL similar to:<\/p>\n
CREATE USER [<app-display-name-or-client-id>] FROM EXTERNAL PROVIDER;\nALTER ROLE db_datareader ADD MEMBER [<principal-name>];\nALTER ROLE db_datawriter ADD MEMBER [<principal-name>];<\/p>\n
If CREATE USER … FROM EXTERNAL PROVIDER fails, verify that the signed-in user is the Microsoft Entra admin for the SQL logical server. If not, set the Entra admin or provide the exact portal or CLI command required.<\/p>\n
If direct EXTERNAL PROVIDER creation fails because Microsoft Entra admin is not configured or service principal resolution fails, diagnose the problem and provide the exact fix. Do not skip this silently.<\/p>\n
For a simplified fallback suitable only for demo, allow SQL authentication using the SQL admin connection string, but label it clearly as a demo fallback and keep secrets out of dab-config.json.<\/p>\n
Step 8: Install Data API builder locally and globally<\/p>\n
Install DAB globally for local convenience:<\/p>\n
dotnet tool install microsoft.dataapibuilder –prerelease -g<\/p>\n
If already installed, update it:<\/p>\n
dotnet tool update microsoft.dataapibuilder –prerelease -g<\/p>\n
Verify:<\/p>\n
dab –version<\/p>\n
Inside the project folder, create a local tool manifest for deployment:<\/p>\n
dotnet new tool-manifest\ndotnet tool install microsoft.dataapibuilder –prerelease<\/p>\n
Verify the manifest exists:<\/p>\n
.config\/dotnet-tools.json<\/p>\n
Step 9: Initialize DAB configuration<\/p>\n
Create or move into the project folder.<\/p>\n
Set local environment variable:<\/p>\n
SQL_CONNECTION_STRING=<connection string><\/p>\n
Use Microsoft Entra service principal authentication where possible:<\/p>\n
Server=tcp:<server>.database.windows.net,1433;Database=<database>;Authentication=Active Directory Service Principal;User Id=<client-id>;Password=<client-secret>;Encrypt=True;TrustServerCertificate=False;<\/p>\n
Initialize:<\/p>\n
dab init –database-type mssql –host-mode Development –connection-string “@env(‘SQL_CONNECTION_STRING’)”<\/p>\n
Configure auth provider for HTTP mode:<\/p>\n
dab configure –runtime.host.authentication.provider AppService<\/p>\n
Add the products entity:<\/p>\n
dab add products –source dbo.products –permissions “authenticated:*”<\/p>\n
Inspect dab-config.json and ensure:<\/p>\n
data-source.database-type is mssql\ndata-source.connection-string is @env(‘SQL_CONNECTION_STRING’)\nruntime.rest.enabled is true\nruntime.graphql.enabled is true\nruntime.mcp.enabled is true\nruntime.host.authentication.provider is AppService\nentities.products exists\nproducts permissions include authenticated all actions<\/p>\n
If MCP is not enabled by default, update the configuration to enable it.<\/p>\n
Step 10: Test locally in HTTP mode<\/p>\n
Start DAB:<\/p>\n
dab start<\/p>\n
Find the local port from output.<\/p>\n
Test:<\/p>\n
REST endpoint for products\nGraphQL endpoint\nMCP endpoint path \/mcp<\/p>\n
The \/mcp path may show an error-looking response in a browser. That is expected because MCP endpoints are for MCP clients, not browser navigation. The test should confirm routing reaches the DAB app and is not a startup or binding failure.<\/p>\n
Document exact local URLs in README.md.<\/p>\n
Step 11: Test local STDIO mode<\/p>\n
Switch auth provider:<\/p>\n
dab configure –runtime.host.authentication.provider Simulator<\/p>\n
Run:<\/p>\n
dab start –mcp-stdio role:anonymous<\/p>\n
Do not leave the config in Simulator mode for App Service deployment.<\/p>\n
Switch back:<\/p>\n
dab configure –runtime.host.authentication.provider AppService<\/p>\n
Step 12: Create App Service resources<\/p>\n
Create the lowest cost practical App Service plan.<\/p>\n
Before creating the web app, inspect available runtimes:<\/p>\n
az webapp list-runtimes –os windows\naz webapp list-runtimes –os linux<\/p>\n
If creating a Windows App Service, use runtime DOTNET:8.<\/p>\n
If creating a Linux App Service, use runtime DOTNETCORE:8.0.<\/p>\n
Choose the runtime string that matches the selected operating system.<\/p>\n
First attempt to use Free F1 if compatible with the selected OS and runtime. If using Linux and F1 is not supported or not practical for this startup scenario, use B1.<\/p>\n
Create App Service Plan and Web App.<\/p>\n
For Windows Free F1:<\/p>\n
az appservice plan create `\n–name $APP_SERVICE_PLAN `\n–resource-group $RESOURCE_GROUP `\n–location $LOCATION `\n–sku F1<\/p>\n
az webapp create `\n–name $WEB_APP `\n–resource-group $RESOURCE_GROUP `\n–plan $APP_SERVICE_PLAN `\n–runtime “DOTNET:8”<\/p>\n
For Linux Basic B1 fallback:<\/p>\n
az appservice plan create `\n–name $APP_SERVICE_PLAN `\n–resource-group $RESOURCE_GROUP `\n–location $LOCATION `\n–sku B1 `\n–is-linux<\/p>\n
az webapp create `\n–name $WEB_APP `\n–resource-group $RESOURCE_GROUP `\n–plan $APP_SERVICE_PLAN `\n–runtime “DOTNETCORE:8.0″<\/p>\n
If the chosen runtime syntax fails, inspect available runtimes again and choose the lowest-cost working runtime. Document the choice.<\/p>\n
Step 13: Configure App Service settings<\/p>\n
Configure SQL_CONNECTION_STRING as an App Service app setting.<\/p>\n
az webapp config appsettings set `\n–name $WEB_APP `\n–resource-group $RESOURCE_GROUP `\n–settings SQL_CONNECTION_STRING=”<redacted-connection-string-value>”<\/p>\n
Use the actual connection string in the command, but do not print it in logs or README.<\/p>\n
Before deploying, explicitly verify that dab-config.json uses @env(‘SQL_CONNECTION_STRING’) and does not contain a literal local or Azure SQL connection string.<\/p>\n
Step 14: Create startup scripts<\/p>\n
Use a local .NET tool manifest for DAB in the deployed App Service content.<\/p>\n
Create startup.sh for Linux App Service:<\/p>\n
#!\/bin\/sh\ndotnet tool restore\ndotnet tool run dab start<\/p>\n
Ensure startup.sh has Unix line endings.<\/p>\n
If the environment supports chmod, run:<\/p>\n
chmod +x startup.sh<\/p>\n
Set Linux App Service startup command to:<\/p>\n
startup.sh<\/p>\n
Use:<\/p>\n
az webapp config set `\n–name $WEB_APP `\n–resource-group $RESOURCE_GROUP `\n–startup-file “startup.sh”<\/p>\n
Create startup.cmd for Windows App Service:<\/p>\n
dotnet tool restore\ndotnet tool run dab start<\/p>\n
Set Windows App Service startup command to:<\/p>\n
startup.cmd<\/p>\n
Use:<\/p>\n
az webapp config set `\n–name $WEB_APP `\n–resource-group $RESOURCE_GROUP `\n–startup-file “startup.cmd”<\/p>\n
Do not rely on a globally installed DAB tool inside App Service. The startup script must restore and run the local tool manifest.<\/p>\n
Step 15: Package and deploy as code<\/p>\n
Create a deployment package containing:<\/p>\n
dab-config.json\n.config\/dotnet-tools.json\nstartup.sh if Linux is used\nstartup.cmd if Windows is used\nREADME.md optional\nany project files required for dotnet tool restore<\/p>\n
Use ZIP deploy.<\/p>\n
If PowerShell Compress-Archive is available:<\/p>\n
Compress-Archive -Path * -DestinationPath deploy.zip -Force<\/p>\n
If native ZIP tooling is missing, use Python\u2019s built-in zipfile module to create the deployment ZIP. Do not stop only because Compress-Archive or zip is unavailable.<\/p>\n
Deploy:<\/p>\n
az webapp deploy `\n–resource-group $RESOURCE_GROUP `\n–name $WEB_APP `\n–src-path deploy.zip `\n–type zip<\/p>\n
Or use the current recommended Azure CLI ZIP deployment command if different. Verify against:<\/p>\n
az webapp deploy –help<\/p>\n
Step 16: Verify App Service startup<\/p>\n
Enable application logging:<\/p>\n
az webapp log config –name $WEB_APP –resource-group $RESOURCE_GROUP –application-logging filesystem –level information<\/p>\n
Tail logs:<\/p>\n
az webapp log tail –name $WEB_APP –resource-group $RESOURCE_GROUP<\/p>\n
Open:<\/p>\n
https:\/\/<web-app-name>.azurewebsites.net<\/p>\n
Open health endpoint if supported:<\/p>\n
https:\/\/<web-app-name>.azurewebsites.net\/health<\/p>\n
Open MCP endpoint:<\/p>\n
https:\/\/<web-app-name>.azurewebsites.net\/mcp<\/p>\n
The \/mcp endpoint may show an error-looking response in the browser. That is expected. Confirm the response is from the DAB app and not from App Service default page, deployment failure, or process startup failure.<\/p>\n
If the app returns 503, inspect logs, verify dotnet tool restore ran, verify the startup script is included in the ZIP package, verify the startup command points to the correct script, and verify the correct App Service runtime string was used.<\/p>\n
Do not report success until App Service logs show DAB started successfully, and REST, GraphQL, and MCP paths are reachable.<\/p>\n
Step 17: Verify REST and GraphQL in Azure<\/p>\n
Test REST:<\/p>\n
https:\/\/<web-app-name>.azurewebsites.net\/api\/products<\/p>\n
Test GraphQL:<\/p>\n
https:\/\/<web-app-name>.azurewebsites.net\/graphql<\/p>\n
If App Service authentication is enabled and requests fail due to auth, document how to sign in or obtain a token.<\/p>\n
Step 18: Configure App Service authentication with Microsoft Entra ID<\/p>\n
Enable App Service authentication if not already enabled.<\/p>\n
Use Microsoft Entra as identity provider.<\/p>\n
Configure the hosted SQL MCP Server as a protected MCP endpoint according to Azure App Service MCP authentication guidance.<\/p>\n
Ensure the authentication provider in dab-config.json remains:<\/p>\n
“provider”: “AppService”<\/p>\n
If dynamic client registration is not supported by the client, document the required preauthorization or client configuration step.<\/p>\n
If testing from a browser-based MCP or agent client, configure App Service CORS for the required origin. Do not use wildcard CORS unless this is explicitly marked as a temporary demo setting.<\/p>\n
Step 19: Produce VS Code MCP client example<\/p>\n
Create .vscode\/mcp.json or equivalent MCP client sample.<\/p>\n
Include both HTTP and STDIO examples.<\/p>\n
HTTP example should point to:<\/p>\n
https:\/\/<web-app-name>.azurewebsites.net\/mcp<\/p>\n
STDIO example should use:<\/p>\n
dotnet\ntool\nrun\ndab\nstart\n–mcp-stdio\nrole:anonymous<\/p>\n
Make clear that HTTP uses AppService authentication and STDIO uses Simulator authentication.<\/p>\n
Step 20: Generate README.md<\/p>\n
Create a polished README.md with:<\/p>\n
Title: SQL MCP Server on Azure App Service without containers<\/p>\n
Sections:<\/p>\n
Overview\nArchitecture\nWhat gets created\nCost notes\nPrerequisites\nSetup\nLocal run\nHTTP vs STDIO transport\nDeploy to Azure App Service\nTest endpoints\nMCP browser error note\nTroubleshooting\nCleanup<\/p>\n
Include the final resource names and URLs.<\/p>\n
Include exact commands used.<\/p>\n
Include a clear warning:<\/p>\n
\u201cThe Azure SQL Database free offer has monthly limits. Keep the database in auto-pause when free limit reached mode to avoid charges. If the free offer could not be applied automatically, complete the portal step before running deployment.\u201d<\/p>\n
Include another clear warning:<\/p>\n
\u201cThis prompt creates a complete demo-grade deployment with security-conscious defaults. Review identity, CORS, database permissions, SKU choices, and cost controls before using it for production.\u201d<\/p>\n
Step 21: Create cleanup script<\/p>\n
Create cleanup.ps1:<\/p>\n
az group delete –name $RESOURCE_GROUP –yes –no-wait<\/p>\n
Also include optional local cleanup:<\/p>\n
Remove generated deploy.zip\nUnset SQL_CONNECTION_STRING\nRemove local DAB tool only if the user requests it, not by default<\/p>\n
Step 22: Final validation summary<\/p>\n
At the end, output a compact summary:<\/p>\n
Resource Group:\nSQL Server:\nSQL Database:\nApp Service Plan:\nWeb App:\nApp URL:\nMCP endpoint:\nREST endpoint:\nGraphQL endpoint:\nLocal config file:\nCleanup command:<\/p>\n
Also list any manual steps that could not be automated.<\/p>\n
Do not stop early unless a required security or billing decision is blocked. Prefer completing the solution end to end with safe defaults.<\/p><\/blockquote>\n","protected":false},"excerpt":{"rendered":"
Run SQL MCP Server on Azure App Service without containers. This walkthrough uses Data API builder to configure authentication, expose MCP, REST, and GraphQL endpoints, and deploy as code.<\/p>\n","protected":false},"author":96788,"featured_media":6627,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1,597,720],"tags":[727,560,711],"class_list":["post-6925","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-azure-sql","category-data-api-builder-2","category-sql-mcp-server-2","tag-azure-app-service","tag-data-api-builder","tag-sql-mcp-server"],"acf":[],"blog_post_summary":"
Run SQL MCP Server on Azure App Service without containers. This walkthrough uses Data API builder to configure authentication, expose MCP, REST, and GraphQL endpoints, and deploy as code.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/azure-sql\/wp-json\/wp\/v2\/posts\/6925","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/azure-sql\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/azure-sql\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/azure-sql\/wp-json\/wp\/v2\/users\/96788"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/azure-sql\/wp-json\/wp\/v2\/comments?post=6925"}],"version-history":[{"count":3,"href":"https:\/\/devblogs.microsoft.com\/azure-sql\/wp-json\/wp\/v2\/posts\/6925\/revisions"}],"predecessor-version":[{"id":6939,"href":"https:\/\/devblogs.microsoft.com\/azure-sql\/wp-json\/wp\/v2\/posts\/6925\/revisions\/6939"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/azure-sql\/wp-json\/wp\/v2\/media\/6627"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/azure-sql\/wp-json\/wp\/v2\/media?parent=6925"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/azure-sql\/wp-json\/wp\/v2\/categories?post=6925"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/azure-sql\/wp-json\/wp\/v2\/tags?post=6925"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
![\"SQL](\"https:\/\/devblogs.microsoft.com\/azure-sql\/wp-content\/uploads\/sites\/56\/2026\/04\/mcp-foundry.svg\")
<\/a><\/p>\n