DEV Community: Oresztesz Margaritisz

Creating Your Own AWS Architect with OpenCode and AWS MCP Servers

Oresztesz Margaritisz — Fri, 06 Feb 2026 12:54:17 +0000

Why OpenCode?

OpenCode is an AI-powered coding agent that gives you unprecedented flexibility in choosing your AI provider. Unlike tools locked to a single vendor, OpenCode supports 75+ LLM providers from major platforms like Anthropic, OpenAI, and AWS Bedrock to local models via Ollama or llama.cpp. Whether you're optimizing for cost, privacy, or specific model capabilities, OpenCode's unified provider system lets you connect any compatible service through a simple /connect command.

This flexibility becomes particularly powerful when building specialized agents. In this article, we'll leverage public AWS MCP (Model Context Protocol) servers to create a powerful architect buddy.

AWS MCP Servers: Extending agents with AWS Context

AWS provides official MCP servers that extend AI assistants with deep AWS knowledge and tooling capabilities. The Model Context Protocol, developed by Anthropic, offers a standardized way to connect AI models to external data sources and tools through a client-server architecture.

The AWS Documentation MCP Server is particularly valuable for architecture work. It provides three core capabilities: fetching and converting AWS documentation pages to markdown format, searching the official AWS documentation using the AWS Search API, and retrieving content recommendations for related AWS services. This means your AI assistant can reference authoritative AWS documentation, verify best practices in real-time, and suggest relevant services based on your architecture requirements.

AWS also offers the AWS Diagram MCP Server, which generates professional architecture diagrams using the Python diagrams package with the complete AWS icon set. Combined with documentation lookup, this enables AI assistants to create accurate, best-practice-compliant architecture diagrams through simple natural language prompts—transforming hours of manual diagramming work into minutes of conversation.

We're going to use the ones above with the combination of a powerful agent specification to create our AWS architect buddy.

Combining the best of both worlds

With the combination of OpenCode and AWS MCPs, you have the flexibility of using any of your LLM provider's license while also having access to the most up-to-date AWS documentation and diagramming capabilities. Unlocking the limits of your vendor's toolkit or pricing model.

Defining MCPs in OpenCode

Prerequisites

To make the MCP servers work, you need uv and graphviz installed and available on your machine.

Configuration

I have a ready-made sample for OpenCode with AWS local MCP servers. To define the AWS MCPs, you have to add them to your opencode.jsonc.

{
    "awslabs.aws-diagram-mcp-server": {
      "type": "local",
      "command": [
        "uvx",
        "awslabs.aws-diagram-mcp-server"
      ],
      "environment": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "enabled": true
    },
    "awslabs.aws-documentation-mcp-server": {
      "type": "local",
      "command": [
        "uvx",
        "awslabs.aws-documentation-mcp-server@latest"
      ],
      "environment": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "enabled": true
    }
  },

Permissions

Make sure that for all other agents the MCP servers above are disabled, by adding the following line to your opencode.jsonc:

  "tools": {
    "awslabs*": false
  },

We're going to enable them only for the AWS architect agent that we define later.

Testing MCP configuration

Check if the specified MCP servers are working correctly with the following OpenCode CLI command:

opencode mcp list

Alternatively you can just type /mcps in OpenCode.

OpenCode - Agent Specification

Fortunately, there are ready-made samples for Claude Code in this repo, so we're not going to start from scratch. I tailored the sample above and added some AWS specifics. You can grab the OpenCode version from here.

Installing the Agent

You can install the agent in various ways. The agent configuration can be found over here. Make sure to save this file in the appropriate location. Either in ~/.config/opencode/agents (global config) or in .opencode/agents for your project specific configuration.

Agent Permissions

If you open the markdown file you'll notice that many of the tools are disabled. All awslabs prefixed tools are turned on to make sure only this agent has access to the MCP servers. More about agent permissions are in the OpenCode documentation.

permissions:
  bash: deny
tools:
  write: false
  read: true
  grep: true
  glob: true
  awslabs*: true

The AWS Architect Buddy in Action

Time for truth, time for giving tasks for our new architect. Start opencode and use the <TAB> key to switch to the Aws-Architect agent.

We're going to use an architecture kata for this exercise.

⚠️Note: All the content below was generated by the agent. I pasted them without any modifications.

Working with NFRs

Summary of Key Quantifiable NFRs

Pillar	Critical Metrics
Operational Excellence	Deploy frequency (weekly), MTTR < 30 min, automated recovery 95%+
Security	Zero data breaches, < 1% false positive cheat detection, PCI-DSS compliant
Reliability	99.9% uptime, RPO < 1 hour, RTO < 2 hours, match completion rate > 98%
Performance	< 50ms latency, 60+ FPS, < 30s matchmaking, < 3s map load
Cost Optimization	< $0.05 per player-hour, 30%+ cost reduction YoY, 70%+ infrastructure utilization
Sustainability	50%+ renewable energy regions, ARM instances where possible, < 2GB RAM usage

Technology Choices

Some of the proposed AWS technology stack by the agent (I skipped some of the boring parts for clarity):

Game-Specific Services

Technology	Use Case	NFR Mapping
Amazon GameLift FlexMatch	Skill-based matchmaking with custom rulesets	< 30 second matchmaking, fair matches
Amazon IVS (Interactive Video Service)	Live streaming for tournament observation (ghost mode)	Low-latency streaming for spectators
Amazon Chime SDK	Voice chat for proximity-based communication	Real-time voice with spatial audio

Compute Performance

Technology	Use Case	NFR Mapping
EC2 C6g/C7g Instances (Graviton3)	ARM-based game servers for better price/performance	40% better performance per dollar
EC2 C6i/C7i Instances	Intel-based game servers for single-threaded performance	High clock speed for game physics
EC2 G5 Instances	GPU-based instances for server-side rendering, AI opponents	GPU acceleration for complex physics
Lambda Provisioned Concurrency	Eliminate cold starts for critical paths (matchmaking, authentication)	< 10ms response time
Lambda SnapStart (Java)	Faster cold starts for Java-based services	10x faster Lambda startup

Data Resilience

Technology	Use Case	NFR Mapping
Amazon DynamoDB Global Tables	Multi-region, active-active database for player profiles, inventories	< 100ms read/write latency globally, 99.999% availability
DynamoDB Point-in-Time Recovery	Continuous backups for 35 days	RPO of seconds, recover from accidental deletes
Amazon Aurora Global Database	Multi-region relational database for transactional data (payments)	Cross-region replication < 1 second lag
Amazon ElastiCache (Redis)	Session state, leaderboards, matchmaking queue	Sub-millisecond latency, 99.99% availability
Amazon S3	User-generated content (maps, weapons), game assets	99.999999999% durability, 99.99% availability
S3 Cross-Region Replication	Replicate UGC and assets to multiple regions	Disaster recovery, local access
AWS Backup	Centralized backup management for all AWS resources	Automated backup scheduling, compliance reporting

Cost Estimates

The agent even included a cost estimate for the stack of choice.

Monthly Cost Breakdown

Service Category	Estimated Monthly Cost
Compute (GameLift, Lambda, ECS)	$80,000
Database (DynamoDB, Aurora, ElastiCache)	$30,000
Storage (S3, EBS)	$10,000
Data Transfer (CloudFront, outbound)	$25,000
API Gateway (WebSocket, REST)	$15,000
Monitoring (CloudWatch, X-Ray, Grafana)	$5,000
Security (WAF, Shield Advanced, GuardDuty)	$5,000
Other (Cognito, SNS, SQS, etc.)	$5,000
TOTAL	~$175,000/month

Cost per player-hour: ~$0.04 (within target of < $0.05)
Optimization opportunities:

Use Spot instances for game servers: 40% savings on compute
Reserved Instances for baseline capacity: 30% additional savings
Optimize data transfer with better CDN caching: 20% savings

Putting all to a diagram

Now, diagramming capabilities are quite limited, but they're still valuable if we want to evaluate multiple choices or get an early draft visualized. Let's do this!

Further improvements

We can even extend this agent with various skills. This can include a Markdown-formatted ADR template, so you can formulate all the wisdom collected by an agent into a set of decision records. I'll do this later in another article with the introduction of additional skills.

References

Steps to Take for an Awesome AWS Deployment Diagram

Oresztesz Margaritisz — Tue, 02 Dec 2025 15:29:14 +0000

Have you often envied the rich and crisp AWS diagrams you see online, but aren't sure how to recreate them with confidence? The tips I've collected may help you improve your deployment diagrams. Get ready to deliver cloud solutions architectures that are robust, scalable, and cost-effective!

Prerequisites

Before jumping into drawing your AWS architecture diagrams, make sure you have the following prerequisites in place:

Declare Your Quality Attributes and NFRs

Ensure you cover all quality attributes and metrics in priority order. You can use a ready-made template to make your work efficient. Some are available publicly:

You can look at the Arc42 quality model here; several examples are available in the template as well.
Well-Architected pillars, for instance Azure or AWS, come with several examples.

Arc42 quality graph showing scalability in the middle

AWS Well-Architected Framework pillars

Understand Higher-Level Technology Strategy and Context

If the organization's architecture is heading in a well-defined direction, your solution should follow the same approach.
Before working on the details of your own diagram, collect all documents that capture relevant technology strategy for your case.

The contextual view from the C4 model helps you concentrate on your surroundings and minimize effort on details. It is strongly recommended to initiate the first steps of your architecture work with this piece. The main focus should be:

Actors using your system
External systems as integration points

Example system context from Arc42

Narrow Down Your Architecture Styles and Patterns

Don't forget that this must be aligned with the higher-level technology strategy.
A comprehensive list of architecture styles and patterns can be found at:

Azure architecture guide
Wikipedia
A comprehensive infographic on software architecture styles from ByteBtyeGo

Research

Collecting Use Cases

The following pages and guides hold valuable blueprints for typical use cases.

Finding comprehensive AWS use-case blueprints can be challenging, as they are often scattered across different AWS resources. Collecting these links in one place makes it easier to find proven architectures and patterns. This helps you quickly apply AWS best practices to your own projects.

As the first step, go through this list of resources to gather relevant use cases for your architecture:

AWS Prescriptive Guidance – make sure you scroll all the way down and check "Guides," "Patterns," and "Strategies."
AWS Reference Architecture Diagrams
AWS Case Studies
AWS Solutions Library – make sure you scroll all the way down and check both "Find solutions by category" and "Browse all solutions."
AWS Architecture Center
AWS Well-Architected Lenses – make sure you check these special well-architected lenses in the "AWS Well-Architected Lenses" section.
AWS Whitepapers & Guides

General Advice Before Starting to Draw

Pay attention to the style and iconography used in the diagrams you find. Notice how groupings are used to distinguish different parts of the architecture, how to display multi-AZ, multi-region setups, and how to represent security boundaries.

Tools for Drawing

After finishing your research, it's time to start drawing your architecture diagrams. Here are some useful resources to help you recreate the AWS style and iconography.

Iconography

Here's a website that provides a full list of AWS icons:

AWS Icons

Diagramming Tools

DrawIO – my favorite tool, able to draw a whole set of different AWS architectures, including all icons. Limited support for 3D AWS deployment views as well.
AWS Composer – able to generate ready-to-deploy IaC, and integrate with IDEs for generative AI-powered suggestions.
CloudCraft – specialized in 3D AWS architecture diagrams with support for cost estimation.

An example 3D deployment view

Refine Your Deployment View

After finishing your first draft, it's time to review your work. The tools below help you ensure that your architecture follows AWS best practices and matches your requirements. Gradually refine and polish your diagram based on the materials below.

AWS Well-Architected Pillars

Make sure you deep dive into each pillar and collect those gudelines which are relevant for your deployment. Use these as a checklist to verify that your architecture meets AWS best practices. Each pillar has its own dedicated whitepaper. I'm going to list them all in here for your convenience:

Evaluating Technologies

Open source projects to find libraries, tools, and resources for your services help narrow down technology choices.

AWS Tools

Serverless Patterns

A full set of serverless patterns with example code and one-click deployment. You can use it to polish a specific area of your architecture if you're considering a serverless architectural style.

Serverlessland

Justify and Explain Your Deployment View

There are some ready-made materials to help make your architecture more understandable. The C4 model is an excellent framework for architecture analysis, so I use most of their provided resources to cross-check my diagrams.

Diagram review checklist
techtribes.je – sample high-level architecture diagram from Simon Brown, showcasing some of the best practices from the diagram review checklist.
Arc42 template – deployment view – The arc42 template offers high-quality, polished guidelines. This section provides specific advice on how to represent deployments.

If you want a quick checklist for AWS deployment views, here's a quick one:

Security:

Are boundaries clear between different AWS accounts, regions, and availability zones?
Are security components (like WAF, AWS Shield, Security Groups, NACLs) included where necessary?
Is public and private subnetting represented? Is it clear which components are in which subnet?

Scalability:

Is autoscaling represented for services that require it?

Availability:

Are boundaries clear between different AWS accounts, regions, and availability zones?
Are edge services (like CloudFront, Route 53, API Gateway) clearly represented?
Is networking between AWS and a physical data center represented (if applicable)?
If this is a multi-region deployment, are the regions and their interactions clearly represented?

Observability (supports all categories):

Is observability clearly represented (CloudWatch, CloudTrail, X-Ray, CloudWatch Logs, etc.)?

techtribes.je - components view

Provide an Explanation for Your Deployment View

Make sure you back up your technology choices represented in the deployment view with explanations. For instance, you can use the "Architecture Decisions" section from the Arc42 template.

Don't Forget About Cost and Capacity Estimates

Crafting a good deployment plan is an iterative process. Make sure you revisit your architecture diagram and refine it based on cost and capacity estimates. For your cost estimates, you can use the AWS Pricing Calculator.

To get realistic price calculations, you need basically two things:

Technology choices, to know which services you are going to use.
Capacity estimates, to be able to fill in the planned workload.

Making good capacity estimates is an art in itself. I recommend a book that provides guidance on how to do it properly: The Art of Capacity Planning

If you need a quick introduction, a short case study is available in a ByteByteGo article here. It uses synthetic sensor traffic and social media feeds as examples to demonstrate how to derive throughput, clustering, and bandwidth. The article also includes a diagram with a high-level overview of different scenarios.

Luckily, a handful of database engines offer guidelines and formulas for estimating capacity.

different capacity planning scenarios

If it turns out that one specific piece of your architecture is too expensive, you don't necessarily have to proceed with it. Instead, explore alternative services or deployment models to reduce costs.

Power of GenAI

If you want to speed up your work, you can use Amazon Q with AWS-provided MCP services as a CLI tool. The generated diagrams are often not enough to meet quality standards, but I think the generated output can be used for exploring different options. Also, with the help of MCP, Amazon Q is able to search inside AWS documentation and help you clarify differences between specific AWS services and deployment models.

Build AWS architecture diagrams using Amazon Q CLI and MCP

Configuring LazyVim and Python on Windows with WSL

Oresztesz Margaritisz — Tue, 25 Mar 2025 07:42:59 +0000

Prerequisites

[OPTIONAL] Install a package manager - `scoop`

You can use Scoop package manager to install various packages. If you want to skip this step, you can install WezTerm manually. Open a PowerShell terminal and type

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression

Install a terminal - `wezterm`

This step is necessary for displaying LazyVim and special icons appropriately. You have to use a terminal that supports LazyVim - wezterm. If you haven't installed scoop, you can just manually download and install WezTerm from here

scoop bucket add extras
scoop install extras/wezterm

First steps - configuring WSL

You can try to run LazyVim from Windows directly, but my experience is that it comes with plenty of tradeoffs and many features are currently broken. I'll try to give an explanation at the end of this article.
Make sure you have WSL2 with latest stable Ubuntu LTS installed.

wsl --list --online
wsl --install -d Ubuntu-24.04

Start wsl

wsl -d Ubuntu-24.04

Reference: https://learn.microsoft.com/en-us/windows/wsl/install

Install command line prerequisites

Install NeoVim latest stable

sudo snap install nvim --classic

Reference: https://github.com/neovim/neovim/blob/master/INSTALL.md#snap

Install LazyGit

LAZYGIT_VERSION=$(curl -s "https://api.github.com/repos/jesseduffield/lazygit/releases/latest" | \grep -Po '"tag_name": *"v\K[^"]*')
curl -Lo lazygit.tar.gz "https://github.com/jesseduffield/lazygit/releases/download/v${LAZYGIT_VERSION}/lazygit_${LAZYGIT_VERSION}_Linux_x86_64.tar.gz"
tar xf lazygit.tar.gz lazygit
sudo install lazygit -D -t /usr/local/bin/

Reference: https://github.com/jesseduffield/lazygit?tab=readme-ov-file#ubuntu

Install gcc, make and other tools (required for nvim-treesitter and for installing python versions)

sudo apt install build-essential \
  dpkg-dev \
  gcc \
  gnupg \
  libbluetooth-dev \
  libbz2-dev \
  libc6-dev \
  libdb-dev \
  libffi-dev \
  libgdbm-dev \
  liblzma-dev \
  libncursesw5-dev \
  libreadline-dev \
  libsqlite3-dev \
  libssl-dev \
  make \
  pkg-config \
  tk-dev \
  uuid-dev \
  wget \
  xz-utils \
  zlib1g-dev

Reference: https://github.com/docker-library/python/blob/0330f0baedb296c8806a869d04fe76838f721647/3.13/slim-bullseye/Dockerfile#L30

Install all other tools to work with fzf-lua. Required for LazyVim to effectively navigate in your project files.

sudo apt install fzf ripgrep fdclone

Install NodeJS with a version manager - `nvm`

Mainly required for the builtin LazyVim package manager, called mason.

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.2/install.sh | bash
nvm install --lts
nvm use --lts

Check if it's working

npm --version

Reference: https://github.com/nvm-sh/nvm?tab=readme-ov-file#installing-and-updating

Install `pyenv` to manage Python environments.

Note, that uv is not supported currently as a Python provider. Also, uv does not allow you to use a specify Python version in your PATH. Follow this open GitHub issue for more information.

curl https://pyenv.run | bash

Change .bashrc to include pyenv features

cat >> ~/.bashrc
export PYENV_ROOT="$HOME/.pyenv"
[[ -d $PYENV_ROOT/bin ]] && export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init - bash)"

Install latest Python version and make it global

pyenv install 3.13
pyenv global 3.13

Reference: https://github.com/pyenv/pyenv-installer?tab=readme-ov-file#install

Ready to Roll! 🚀

At this point, you're ready to install LazyVim and take the first look. For the reference this command is taken from here

Make a backup of your current Neovim files:

# required
mv ~/.config/nvim{,.bak}

# optional but recommended
mv ~/.local/share/nvim{,.bak}
mv ~/.local/state/nvim{,.bak}
mv ~/.cache/nvim{,.bak}

Clone the starter

git clone https://github.com/LazyVim/starter ~/.config/nvim

Remove the .git folder, so you can add it to your own repo later

rm -rf ~/.config/nvim/.git

Start Neovim for the first time!

nvim

You should see the package manager installing packages, wait until it finishes.

Checking installation

Type :LazyHealth to open up the window showing package statuses.

Using `LazyVim Extras` to install Python IDE

Next type :LazyExtras to go to the LazyVim Extras. Type / python to search for Python related packages.

Press x to install related packages (at the cursor, called lang.python). Do the same for dap.core, test.core editor.refactoring, lang.json, lang.markdown, and lang.toml. Optionally you can install ui.mini-animate for an animated cursor and coding.yanky for and advanced clipboard experience.

Press q to quit LazyExtras.

Configuring plugins

Your next step will be to configure some of the Python plugins to ensure, that they're working as you expect. Start LazyVim with the following command to edit your configuration:

nvim ~/.config/nvim

First thing to do is to configure the Python extra by setting your LSP server + Ruff command. Edit your lua/config/options.lua file and these lines:

-- LSP Server to use for Python.
-- Set to "basedpyright" to use basedpyright instead of pyright.
vim.g.lazyvim_python_lsp = "pyright"
-- Set to "ruff_lsp" to use the old LSP implementation version.
vim.g.lazyvim_python_ruff = "ruff"

Reference: https://www.lazyvim.org/extras/lang/python#options

Create a test.lua under nvim/lua/plugins folder and configure it like the example below:

return {
  "nvim-neotest/neotest",
  opts = {
    adapters = {
      ["neotest-python"] = {
        dap = { justMyCode = false },
        args = { "--capture=no" },
        pytest_discover_instances = true,
      },
    },
  },
}

This will ensure, that neotest and neotest-python allows you to:

flush output buffer during testing, so stdout and stderr messages are appearing, while tests are running
set breakpoints and debug inside library code

Next you should create a debug.lua under nvim/lua/plugins folder and configure it like the example below:

return {
  {
    "mfussenegger/nvim-dap-python",
    opts = {
      justMyCode = false,
    },
  },
}

This will ensure, that nvim-dap and nvim-dap-python allows you to set breakpoints and debug inside library code. The end result should look something like this:

Creating your first python project

We'll use pyenv to create a Python project and a virtual environment. Also add pytest package to verify if testing and debugging works well.

mkdir python-sandbox && cd python-sandbox
pyenv global 3.13
python -m venv .venv
. .venv/bin/activate

Install pytest executables for testing under your local project

pip install pytest

Make sure you have your local project in the PYTHONPATH on bash. You can start LazyVim now within your project.

PYTHONPATH=`pwd`:$PYTHONPATH nvim .

Checking if key features are working

LSP

After creating a Python project you can use <leader>cl to view the LSP config. You should be able to see pyright and ruff at the top of the list with its settings.

Testing

You need to verify if your Neotest is interacting properly with neotest-python.

Create a simple pytest test-case and use <leader>ts for showing up all your test functions implemented under the project. Use r to run one of your tests to ensure, that things are wired together properly.

Debugging

Final thing to verify if nvim-dap is interacting with nvim-dap-python correctly. Put a breakpoint in your code, by using <leader>db on a line. Next, start a test after showing up all the test functions with pressing d on the test case's name.

Refactoring

Stop on a function and try hitting <leader>rs for showing the refactoring menu. You should be able to do simple things, like extracting a new function under selection by pressing f.

Final thoughts

Limited functionality under Windows

I found out, that testing and debugging has several broken features if you run them from Windows natively. I haven't looked at the root cause, but one of the possible issues are inside nvim-dap-python and neotest-python libraries providing debugging and testing functionality. These extension libraries have to make distinction between Windows and Linux runtimes as binaries and virtual environments follow a different convention (e.g. venv/bin/python VS venv/Scripts/pythonw). These "conditions" and special cases are often getting broken and patched afterwards.

Using `uv` as a Python version manager

Currently it seems like uv is not supporting global python versions you can see from this GitHub ticket. If you really like the speed and performance of uv you can try to combine the best of both worlds: Using pyenv for managing global Python versions and using uv for managing your project-specific dependencies.

Configuring LazyVim and Python on Windows

Oresztesz Margaritisz — Tue, 18 Mar 2025 06:49:25 +0000

Prerequisites

Install a package manager - `scoop`

This step is required to simplify subsequent installation steps. Use the Scoop package manager to install various packages. Open a PowerShell terminal and type

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression

Install a terminal - `wezterm`

This step is necessary for displaying LazyVim and special icons appropriately. Use a terminal that supports LazyVim - wezterm

scoop bucket add extras
scoop install extras/wezterm

Install command line prerequisites

These shell commands are used with LazyVim, a comprehensive list can be found at the official documentation

scoop bucket add main
scoop install main/git main/neovim main/curl main/gcc main/fzf main/fd main/ripgrep main/unzip extras/lazygit

Install NodeJS with a version manager - `nvm`

Required for mason - a package manager used by LazyVim to install various packages

scoop install main/nvm
nvm install lts
nvm use lts

Check if it's working

npm --version

Install version manager for your programming language - `pyenv`

Note, that uv is not supported currently as a Python provider. Also, uv does not allow you to use a specify Python version in your PATH. Follow this open GitHub issue for more information.

Make sure you're using scoop as an administrator to install pyenv correctly.

scoop install main/pyenv
pyenv install 3.11.0b4
pyenv global 3.11.0b4

Reference: https://github.com/pyenv-win/pyenv-win/issues/449

Check if it's working

python --version

Ready to Roll! 🚀

At this point, you're ready to install LazyVim and take the first look. For the reference this command is taken from here

Make a backup of your current Neovim files:

# required
Move-Item $env:LOCALAPPDATA\nvim $env:LOCALAPPDATA\nvim.bak

# optional but recommended
Move-Item $env:LOCALAPPDATA\nvim-data $env:LOCALAPPDATA\nvim-data.bak

Clone the starter

git clone https://github.com/LazyVim/starter $env:LOCALAPPDATA\nvim

Remove the .git folder, so you can add it to your own repo later

Remove-Item $env:LOCALAPPDATA\nvim\.git -Recurse -Force

Start Neovim!

nvim

You should see the package manager installing packages, wait until it finishes.

Checking installation

Type :LazyHealth to open up the window showing package statuses.

Using `LazyVim Extras` to install Python IDE

Next type :LazyExtras to go to the LazyVim Extras. Type / python to search for Python related packages.

Press q to quit LazyExtras.

Configuring plugins

Your next step will be to configure some of the Python plugins to ensure, that they're working as you expect. Start LazyVim with the following command to edit your configuration:

nvim $env:LOCALAPPDATA\nvim

First thing to do is to configure the Python extra by setting your LSP server + Ruff command. Edit your lua/config/options.lua file and these lines:

-- LSP Server to use for Python.
-- Set to "basedpyright" to use basedpyright instead of pyright.
vim.g.lazyvim_python_lsp = "pyright"
-- Set to "ruff_lsp" to use the old LSP implementation version.
vim.g.lazyvim_python_ruff = "ruff"

Reference: https://www.lazyvim.org/extras/lang/python#options

Create a test.lua under nvim/lua/plugins folder and configure it like the example below:

return {
  "nvim-neotest/neotest",
  opts = {
    adapters = {
      ["neotest-python"] = {
        dap = { justMyCode = false },
        args = { "--capture=no" },
        pytest_discover_instances = true,
      },
    },
  },
}

This will ensure, that neotest and neotest-python allows you to:

flush output buffer during testing, so stdout and stderr messages are appearing, while tests are running
set breakpoints and debug inside library code

Next you should create a debug.lua under nvim/lua/plugins folder and configure it like the example below:

return {
  {
    "mfussenegger/nvim-dap-python",
    opts = {
      justMyCode = false,
    },
  },
}

This will ensure, that nvim-dap and nvim-dap-python allows you to set breakpoints and debug inside library code. The end result should look something like this:

Fixing possible `debugpy` issues

Ensure, that you're disabling alias for python and python3 under your Windows settings!

You might require to install debugpy with Mason again. You can do this with the :MasonInstall debugpy@1.8.12 command

Creating your first python project

We'll use uv to generate a Python project and create a virtual environment. Also add pytest package to verify if testing and debugging works well.

mkdir python-sandbox
cd python-sandbox
python -m venv .venv
.venv\Scripts\activate

Install pytest executables for testing under your local project

pip install pytest

Make sure you have your local project in the PYTHONPATH on PowerShell. You can start LazyVim now within your project.

$env:PYTHONPATH = $pwd
nvim .

Checking if key features are working

Testing

You need to verify if your Neotest is interacting properly with neotest-python.

Debugging

Refactoring

Stop on a function and try hitting <leader>rs for showing the refactoring menu. You should be able to do simple things, like extracting a new function under selection by pressing f.

DEV Community: Oresztesz Margaritisz

Creating Your Own AWS Architect with OpenCode and AWS MCP Servers

Why OpenCode?

AWS MCP Servers: Extending agents with AWS Context

Combining the best of both worlds

Defining MCPs in OpenCode

Prerequisites

Configuration

Permissions

Testing MCP configuration

OpenCode - Agent Specification

Installing the Agent

Agent Permissions

The AWS Architect Buddy in Action

Working with NFRs

Technology Choices

Game-Specific Services

Compute Performance

Data Resilience

Cost Estimates

Monthly Cost Breakdown

Putting all to a diagram

Further improvements

References

Steps to Take for an Awesome AWS Deployment Diagram

Prerequisites

Declare Your Quality Attributes and NFRs

Understand Higher-Level Technology Strategy and Context

Narrow Down Your Architecture Styles and Patterns

Research

Collecting Use Cases

General Advice Before Starting to Draw

Tools for Drawing

Iconography

Diagramming Tools

Refine Your Deployment View

AWS Well-Architected Pillars

Evaluating Technologies

Serverless Patterns

Justify and Explain Your Deployment View

Provide an Explanation for Your Deployment View

Don't Forget About Cost and Capacity Estimates

Power of GenAI

Configuring LazyVim and Python on Windows with WSL

Prerequisites

[OPTIONAL] Install a package manager - scoop

Install a terminal - wezterm

First steps - configuring WSL

Install command line prerequisites

Install NodeJS with a version manager - nvm

Install pyenv to manage Python environments.

Ready to Roll! 🚀

Checking installation

Using LazyVim Extras to install Python IDE

Configuring plugins

Creating your first python project

Checking if key features are working

LSP

Testing

Debugging

Refactoring

Final thoughts

Limited functionality under Windows

Using uv as a Python version manager

Configuring LazyVim and Python on Windows

Prerequisites

Install a package manager - scoop

Install a terminal - wezterm

Install command line prerequisites

Install NodeJS with a version manager - nvm

Install version manager for your programming language - pyenv

Ready to Roll! 🚀

Checking installation

Using LazyVim Extras to install Python IDE

Configuring plugins

Fixing possible debugpy issues

Creating your first python project

Checking if key features are working

Testing

Debugging

[OPTIONAL] Install a package manager - `scoop`

Install a terminal - `wezterm`

Install NodeJS with a version manager - `nvm`

Install `pyenv` to manage Python environments.

Using `LazyVim Extras` to install Python IDE

Using `uv` as a Python version manager

Install a package manager - `scoop`

Install a terminal - `wezterm`

Install NodeJS with a version manager - `nvm`

Install version manager for your programming language - `pyenv`

Using `LazyVim Extras` to install Python IDE

Fixing possible `debugpy` issues

Using `uv` as a Python version manager