Merge branch 'main' of https://github.com/DefangLabs/defang-docs

Author: raphaeltm

.github/CODEOWNERS

@@ -0,0 +1,2 @@
+# CODEOWNERS file automatically generated based on git history
+*                               @DefangLabs/devs 

.gitignore

@@ -21,4 +21,5 @@ yarn-error.log*
 
 defang
 samples
-/static/samples-v2.json
+/docs/samples.md
+/static/samples-v2.json

blog/2025-06-06-may-product-updates.md

@@ -1,7 +1,6 @@
 ---
 title: "May 2025 Defang Compose Update"
 description: "Monthly product updates from the Defang team - May 2025"
-slug: 2025-06-06-product-update
 tags:
   [
     Cloud,

blog/2025-06-16-crew-ai-sample.md

@@ -1,7 +1,6 @@
 ---
 title: "Sample: Starter Kit for RAG + Agents with CrewAI"
 description: "Going over our sample for RAG + Agents with CrewAI"
-slug: rag-agents-crewai-sample
 tags: [Cloud, NoDevOps, Docker Compose, Defang, Sample]
 author: Defang Team
 ---
@@ -89,4 +88,3 @@ DEFANG_PROVIDER=<provider> defang compose up
 ```
 
 Want more? File an [issue](https://github.com/DefangLabs/samples/issues) to request a sample—we'll do everything we can to help you deploy better and faster!
-

blog/2025-06-16-docker-compose-defang.md

@@ -1,7 +1,6 @@
 ---
 title: "Bridging Local Development and Cloud Deployment"
 description: "Announcing our new whitepaper: Bridging Local Development and Cloud Deployment with Docker Compose and Defang"
-slug: defang-docker-compose
 tags: [Cloud, NoDevOps, Docker Compose, Defang, Whitepaper]
 author: Defang Team
 ---

blog/2025-07-10-june-product-updates.md

@@ -0,0 +1,79 @@
+---
+title: "June 2025 Defang Compose Update"
+description: "Monthly product updates from the Defang team - June 2025"
+slug: 2025-07-10-product-update
+tags:
+  [
+    Cloud,
+    NoDevOps,
+    BYOC,
+    MCP,
+    LLMs,
+    Vibe Deploying,
+    GCP,
+    AWS,
+    Events,
+    Defang Compose Update,
+  ]
+author: Defang Team
+---
+
+![Defang Compose Update](/img/defang-compose-update.webp)
+
+June was a big month at Defang. We rolled out powerful features across our CLI, Playground, and Portal, expanded support for both AWS and GCP, and introduced new tools to help you ship faster and smarter. From real-time cloud cost estimation to internal infra upgrades and community highlights, here’s everything we accomplished.
+
+## 🚀 Live AWS Cost Estimation
+
+We just launched something we’re really excited about: live AWS cost estimation before you deploy.
+Most devs ship to the cloud without knowing what it’s going to cost and that’s exactly the problem we’re solving. With Defang, you can now estimate the cost of deployment of an Docker Compose application and choose the deployment mode - affordable / balanced / high_availability - that best suits your needs.
+
+👉 [Check out the docs](https://docs.defang.io/docs/tutorials/estimating-aws-deployment-costs)
+
+## 🧠 CrewAI + Defang Starter Kit
+
+In June, we launched a full-stack starter kit for building real-time RAG and multi-agent apps with CrewAI + Defang.
+It’s designed to help you move fast with a production-style setup — including Django, Celery, Channels, Postgres (with pgvector), Redis for live updates, and Dockerized model runners you can easily customize. CrewAI handles the agent workflows, and with Defang, you can deploy the whole thing to the cloud in a single command.
+Whether you’re building a smart Q&A tool or a multi-agent research assistant, this stack gives you everything you need to get started.
+
+👉 [Try it out here](https://github.com/DefangSamples/sample-crew-django-redis-postgres-template)
+
+## 📊 Deployment Info in Portal
+
+We’ve added active deployment information to the Defang Portal. You can now see your currently active deployments across various cloud providers and understand the details of each, while still managing your cloud environments through the provider’s own tools (e.g. the AWS Console).
+
+## ☁️ Playground Now Runs on AWS + GCP
+
+Internally, we also hit a big milestone: The Defang Playground now runs on both AWS and GCP, showing the power of Defang’s multi-cloud infrastructure. We’ve also enabled load balancing between the two platforms and plan to share a detailed blog post on how it works soon.
+
+## 🧩 VS Code Extension Released
+
+We also released the Defang VS Code Extension, making it even easier to deploy and manage cloud apps right from your editor. No terminal needed.
+
+- One-click deploy
+- Built-in tools to manage services
+- Zero config, fast setup
+
+👉 [Try it out here](https://marketplace.visualstudio.com/items?itemName=DefangLabs.defang)
+
+## 💬 Ask Defang via Intercom
+
+You can now try out the Ask Defang chatbot directly within Intercom! This new integration makes it easier than ever to get instant answers and support while you work. Ask Defang itself is deployed using Defang to our own cloud infrastructure.
+
+## 🐳 Docker x Defang White Paper
+
+And one more thing: bridging local development and cloud deployment just got easier. We’ve published white papers on how Defang extends Docker Compose and GCP workflows to the cloud — using familiar tools at scale. An AWS white paper is coming soon.
+
+👉 [Read the white paper here](https://defang.io/whitepapers/docker-compose-defang/)
+
+👉 [Read the GCP white paper](https://defang.io/whitepapers/gcp-defang/)
+
+## Events and Community
+
+In June, we showcased a powerful new demo at AWS events: “What If You Could See AWS Costs Before You Deployed?” Jordan Stephens walked through how to go from Docker Compose to AWS infra with real-time cost estimates and easy teardown, all via Defang.
+
+👉 [Watch the demo here](https://www.youtube.com/watch?v=YHmE_6MgcYA)
+
+We can’t wait to see what you deploy with Defang.  
+👉 [Join our Discord](https://discord.gg/9FF5MFAm)
+
+More coming in July.

blog/2025-07-14-defang-gcp-compose.md

@@ -0,0 +1,45 @@
+---
+title: "Simple, Secure, and Scalable GCP Deployments from Docker Compose"
+description: "Announcing our latest whitepaper: How Defang simplifies Google Cloud deployments with Docker Compose"
+slug: defang-gcp-compose
+tags: [Google Cloud, GCP, Docker Compose, Cloud Deployment, Defang, Whitepaper]
+author: Defang Team
+---
+
+**Introducing Our New Whitepaper: Simple, Secure, and Scalable GCP Deployments from Docker Compose**
+
+We’re excited to share our latest whitepaper, _Defang + GCP: Simple, Secure, and Scalable Deployments from Docker Compose_.
+
+:::tip[Want to skip the blog?]
+[Read the full whitepaper here.](https://defang.io/whitepapers/gcp-defang/)
+:::
+
+Deploying to Google Cloud Platform (GCP) doesn’t have to be complicated. Docker Compose made defining local apps simple, and Defang makes cloud deployments just as easy.
+
+With Defang, you can:
+
+- **Deploy to GCP with a single command.** Go from Compose to Cloud Run, Cloud SQL, and more with just `defang compose up --provider=gcp`.
+- **Skip the DevOps overhead.** No need for Terraform, Pulumi, or custom scripts. Defang maps your Compose services to the right GCP resources — compute, storage, networking, and even managed LLMs.
+- **Enjoy built-in security and scalability.** Defang automates GCP best practices, handling service accounts, secret management, HTTPS, auto-scaling, and more.
+- **Integrate with your workflow.** Deploy from your terminal, GitHub Actions, or even natural language prompts in VS Code, Cursor, or Windsurf.
+- **Save costs and avoid surprises.** Choose from affordable, balanced, or high-availability modes with built-in cost estimation coming soon.
+
+Our whitepaper walks through how Defang integrates with GCP, including how it:
+
+✅ Builds your containers using Cloud Build  
+✅ Manages secure deployments via Cloud Run and managed services  
+✅ Supports custom domains, advanced networking, GPUs, LLMs, and more  
+✅ Powers CI/CD pipelines with GitHub Actions and Pulumi
+
+It also highlights how Defang itself deploys real apps like our Ask Defang chatbot using less than 100 lines of Compose on GCP.
+Want to simplify your GCP deployments? Start with Compose, scale with Defang.
+
+import Link from '@docusaurus/Link';
+
+<div style={{marginTop: '2rem', marginBottom: '2rem'}}>
+  <Link
+    className="button button--primary button--lg"
+    to="https://defang.io/whitepapers/gcp-defang/"
+    children="Read the full whitepaper"
+  />
+</div>

blog/2025-08-07-defang-ai-devops-agent.md

@@ -0,0 +1,62 @@
+---
+title: "Defang: Your AI DevOps Agent"
+description: "From Vibe-Coding to Production… Without a DevOps Team"
+slug: defang-your-ai-devops-agent
+tags: [Cloud, NoDevOps, BYOC, MCP, LLMs, Vibe Deploying, GCP, AWS]
+author: Defang Team
+---
+
+![Defang Agent](/img/defang_agent/defang_agent.png)
+
+## From Vibe-Coding to Production… Without a DevOps Team
+
+Building apps has never been easier. Tools like Cursor, Windsurf, Lovable, V0, and Bolt have ushered in a new era of coding called **vibe coding**, rapid, AI-assisted app development where developers can go from idea to prototype in hours, bringing ideas to life faster than ever before.
+
+And with the recently released AWS Kiro, we have now entered a new phase of AI-assisted development called "spec-driven development" where the AI breaks down the app development task even further. You can think of a "PM agent" that goes from prompt to a requirements document, and then an "Architect agent" that goes from the requirements document to a design document, which is then used by "Dev", "Test" and "Docs" agents to generate app code, tests, and documentation respectively. This approach is much more aligned with enterprise use cases and produces higher quality output.
+
+## The Hard Part Isn’t Building. It’s Shipping.
+
+However, cloud app deployment remains a major challenge! As Andrej Karpathy shared during his [recent YC talk](https://www.youtube.com/watch?v=LCEmiRjPEtQ):
+
+> "_I vibe-coded the app in four hours… and spent the rest of the week deploying it._"
+
+While AI-powered tools make building apps a breeze, deploying them to the cloud is still frustratingly complex. Kubernetes, Terraform, IAM policies, load balancers, DNS, CI/CD all add layers of difficulty. This complexity continues to be a significant bottleneck that AI tools have yet to fully address, making deployment a critical challenge for developers.
+
+The bottleneck is no longer the code. It's the infrastructure.
+
+## Enter Defang: Your AI DevOps Agent
+
+**Defang** is an AI-enabled agent that takes care of your entire deployment workflow, going from app code to a production-ready deployment on your favorite cloud in a single step.
+
+By understanding your app stack (using Docker Compose), **Defang** provisions the right infrastructure and securely deploys to AWS, GCP, or DigitalOcean, following each cloud's best practices.
+
+Whether you're launching a side project or scaling a multi-agent app, **Defang** ensures secure, smooth, scalable cloud-native deployments.
+
+## Defang Deployment Features at a Glance
+
+- **One Command Deployment:** Run `defang compose up` and you're live
+- **Secure and Scalable:** Built-in TLS, secrets, autoscaling, IAM, and HTTPS
+- **Multi-Cloud Ready:** Deploy to your cloud (AWS, GCP, DO) using your own credentials
+- **Language & framework agnostic:** Next.js, Go, Python (Django/Flask), C#, …
+- **Managed LLM:** Add `x-defang-llm: true` and **Defang** auto-configures cloud-native LLMs like Bedrock, Vertex AI, and the Defang Playground
+- **Configures managed services** (e.g. managed Postgres, MongoDB, Redis) using the target cloud's native services (e.g. RDS for Postgres on AWS, Cloud SQL on GCP).
+- **Tailored deployment modes** (e.g. affordable, balance, high-availability) optimized for different environments (dev, staging, production)
+- **AI Debugging:** Get context-aware assistance to quickly identify and fix deployment issues
+
+## Native Integration with AI-Assisted Coding Tools
+
+**Defang** can be accessed directly from within your favorite IDE - Cursor, Windsurf, VS Code, Claude, or Kiro - via [Defang's MCP Server](https://docs.defang.io/docs/concepts/mcp). You can now deploy to the cloud with a natural language command like "deploy my app with Defang".
+
+## For Developers and CTOs Who Want to Move Fast
+
+If you're a developer shipping fast or a CTO scaling lean, **Defang** acts as your drop-in DevOps engineer without needing to build a team around it.
+
+You focus on building great software.  
+**Defang** gets it live.
+
+## Try Defang Now
+
+- Deploy your full-stack app with a single command
+- Explore [samples and templates](https://docs.defang.io/docs/samples)
+- Join our [Discord community](https://discord.gg/muaCHNBN6G)
+- Check out our [YouTube channel](https://www.youtube.com/@DefangLabs) for tutorials

blog/2025-08-12-july-product-updates.md

@@ -0,0 +1,47 @@
+---
+title: "July 2025 Defang Compose Update"
+description: "Monthly product updates from the Defang team - July 2025"
+slug: 2025-08-12-product-update
+tags:
+  [
+    Cloud,
+    NoDevOps,
+    BYOC,
+    GCP,
+    AWS,
+    AI,
+    LLMs,
+    Railpack,
+    Cost Estimation,
+    Defang Compose Update,
+  ]
+author: Defang Team
+---
+
+![Defang Compose Update](/img/defang-compose-update.webp)
+
+July was all about making cloud deployments even smoother and smarter. We focused on removing friction from deployments and giving you better visibility into costs. Railpack now builds production-ready images automatically when no Dockerfile is present, and our real-time cost estimation feature now supports Google Cloud alongside AWS. We also added managed MongoDB on GCP, introduced an Agentic LangGraph sample, and connected with builders at Bière & Code & Beer MTL. Here’s what’s new.
+
+## Railpack Integration
+
+We’ve integrated [Railpack](https://docs.defang.io/docs/concepts/railpack) into Defang to make deployments even smoother. Railpack automatically builds OCI-compliant images from your source code with minimal configuration. This helps eliminate one of the most common issues our users face: missing or invalid Dockerfiles, especially when they’re generated by LLMs or created by users with limited Docker experience. Now, if no Dockerfile is provided, Defang will seamlessly use Railpack to build a working image for you, so you can focus on your code, not your container setup.
+
+## GCP Cost Estimation
+
+In June, Defang announced real-time cost estimation for AWS. In July, we took our [live cloud cost estimation](https://docs.defang.io/docs/concepts/estimation) to the next level by extending support to GCP. Defang now makes it easy to compare real-time pricing for both cloud providers. All you need is your project's compose.yaml file. Whether you’re optimizing for cost, performance, or flexibility, Defang makes it easy to get the information you need to deploy with confidence.
+
+## Managed MongoDB on GCP
+
+Defang now supports [managed MongoDB](https://docs.defang.io/docs/concepts/managed-storage/managed-mongodb) on GCP through MongoDB-compatible APIs provided by Google Cloud. This integration allows you to spin up a fully managed Firestore datastore and interact with it just like a standard MongoDB instance without any manual setup or configuration.
+
+## Agentic LangGraph Sample
+
+We have published a new [Agentic LangGraph sample](https://github.com/DefangSamples/sample-agentic-langgraph-template/tree/main) project that demonstrates LangGraph agent deployment with Defang. As AI agent development grows, Defang makes it simple to deploy and scale agents, including those built with LangChain or LangGraph. You can explore the example to see how it works in practice.
+
+## Events and Community
+
+In July, we hosted the [Bière & Code & Beer MTL](https://www.linkedin.com/feed/update/urn:li:activity:7350573195004952578) during Startupfest in Montreal. It was an incredible evening with great energy, tech conversations, and the chance to connect with so many talented builders over drinks.
+
+We are excited to see what you will deploy with Defang next. Join our [Discord](https://s.defang.io/discord) to ask questions, get support, and share your builds with the community.
+
+More coming in August.

blog/2025-08-22-agentic-apps.md

@@ -0,0 +1,74 @@
+---
+title: "Deploying Agentic Apps to the Cloud Shouldn’t Be This Hard…"
+description: "Agentic apps, cloud-native infrastructure, and how Defang simplifies deployment"
+slug: agentic-apps
+tags:
+  [Agentic Apps, AI, LLMs, Cloud, AWS, GCP, DigitalOcean, DevOps, Deployments]
+author: Defang Team
+---
+
+![Agentic Apps](/img/agentic-apps/agentic-apps.png)
+
+## Deploying Agentic Apps to the Cloud Shouldn’t Be This Hard…
+
+Agentic apps are redefining how software is built: multi-agent workflows, persistent memory, tool-using LLMs, and orchestrated autonomy. But deploying them to the cloud is still painful - for example, your agentic app typically needs to provision:
+
+- Managed databases like Postgres or MongoDB
+- Fast, scalable caching (hello Redis)
+- Containerized compute that scales
+- Secure networking and service discovery
+- Managed LLMs like AWS Bedrock or GCP Vertex AI
+
+And for many teams, these apps must run inside the customer’s cloud, where sensitive data lives and compliance rules apply. That means you cannot just spin up your own environment and call it a day. Instead, you are deploying across AWS, GCP, DigitalOcean, or whichever stack your customers demand, each with its own APIs, quirks, and limitations.
+
+Now you are not just building agents; you are picking the right infrastructure, rewriting IaC templates for every provider, and untangling the edge cases of each cloud.
+
+The result: weeks of DevOps headaches, lost momentum, and engineers stuck wiring infrastructure instead of shipping agents.
+
+## We Made it Simple with Cloud Native Support for Agentic Apps
+
+That’s where Defang comes in. We make it easy to deploy full-stack agentic apps to your cloud of choice: native, secure, and scalable.
+Defang understands the common ingredients of agentic apps and makes them first-class citizens:
+
+- Compute: Your Dockerized services deploy as cloud-native workloads (e.g. AWS ECS, or GCP Cloud Run)
+- Databases: Provision managed Postgres or MongoDB with one config line
+- Caching: Add Redis and Defang spins up a managed Redis instance in your cloud
+- LLMs: Integrate directly with Bedrock or Vertex AI - even provision an OpenAI gateway for compatibility with OpenAI APIs.
+- Secure Defaults: : TLS, secrets, IAM, and service accounts handled out of the box
+
+## Built for All your Favorite Agentic Frameworks
+
+Defang works seamlessly with leading agentic frameworks. Try them out with our ready-to-deploy samples:
+
+- [Autogen](https://github.com/DefangLabs/samples/tree/main/samples/agentic-autogen) - demo featuring Mistral AI + FastAPI, deployable with Defang’s OpenAI Access Gateway.
+- [CrewAI](https://docs.defang.io/blog/2025/06/16/crew-ai-sample) - sample app showing multi-agent orchestration in action.
+- [LangGraph](https://github.com/DefangLabs/samples/tree/main/samples/agentic-langgraph) - workflow sample that defines and controls multi-step agentic graphs with LangChain.
+- [Agentic Strands](https://github.com/DefangSamples/sample-agentic-strands-template/tree/main) - A Strands Agent application.
+
+
+More framework templates coming soon.
+
+## Why It Matters
+
+Agentic apps need to be fast, secure, and ready to scale. Defang delivers cloud-native deployments in your environment (AWS, GCP, DO), so you can move from idea to production quickly with consistent behavior across dev, test, and prod.
+
+## The Developer Journey, Simplified
+
+1. Build your agentic app locally using Docker Compose
+2. Test in Defang's free playground with `defang compose up`
+3. Deploy to your cloud:
+
+```bash
+defang compose up --provider=aws  # or gcp, digitalocean
+```
+
+It just works. No Terraform. No YAML explosion. No vendor lock-in.
+
+## The Future of AI Apps Is Agentic and Cloud-Native
+
+Agility and scalability should not be a trade-off. With Defang, you get both. Developers focus on agents, tools, and outcomes. Defang takes care of the cloud infrastructure.
+
+## Try it out
+
+Explore more samples at [docs.defang.io](https://docs.defang.io)
+Join our community on [Discord](https://s.defang.io/discord)