DEV Community: Jenna Pederson

Stop over-engineering your n8n RAG pipeline before you've shipped anything

Jenna Pederson — Mon, 23 Mar 2026 15:00:00 +0000

I see this pattern a lot in n8n: a developer sets out to build a RAG-powered feature and ends up three days deep configuring (and reconfiguring) text splitters, embedding models, rerankers, and debugging — without a working system to show for it.

It's a real productivity trap, and it's partly an artifact of how RAG is usually taught. Most tutorials step through the full pipeline from scratch: load documents, split them, embed them, store them, retrieve them, rerank them, generate. You internalize the idea that understanding and owning each step is the price of admission.

For learning, that's fine. For shipping, it's often the wrong starting point.

Two n8n nodes, two different commitments

When building RAG workflows in n8n, you have two primary options for working with Pinecone:

The Pinecone Assistant node is a managed RAG pipeline. You add documents to an Assistant, and Pinecone handles chunking, embedding, query planning, semantic search, and reranking automatically. In your workflow, you work with a single node. The pipeline decisions are made for you — based on Pinecone's retrieval best practices — and they update automatically as the Assistant product improves.

The Pinecone Vector Store node gives you direct access to the vector database. You build the pipeline yourself: choose your chunking strategy, choose your embedding model, implement your search approach, add a reranker if you need one. You control every variable. You also debug every failure.

Neither node is inherently better. They represent different tradeoffs, and the right choice depends on what you're actually building — not on which gives you more control.

The bias toward complexity

I think engineers are often drawn to the option with more control — I've felt this pull myself, often out of curiosity of "how does this thing really work?" But here's the thing: it makes sense in systems where the details of implementation create meaningful product differentiation. It makes less sense in systems where the infrastructure is not the product.

For most RAG applications, the retrieval pipeline is not the product. It's the thing that enables the product. A customer support chatbot, an internal knowledge base, a documentation search tool — these applications succeed or fail based on how well they serve users, not based on which chunking algorithm was used under the hood.

When the retrieval pipeline becomes a thing you maintain, tune, and debug continuously, it consumes engineering attention that could go toward the features users actually see. The Pinecone Assistant node is designed to prevent that: managed retrieval as a building block, not a maintenance burden.

When the details actually matter

There are real scenarios where custom pipeline control earns its complexity. The Vector Store node is the right choice when:

Your content has specialized retrieval requirements. Legal documents often require clause-level chunking precision that generic strategies miss. Technical documentation with code snippets may need language-aware processing. Multilingual content benefits from language-specific embedding models. If your content type has characteristics that standard chunking handles poorly, you need access to those controls.

You require a specific embedding model. Fine-tuned models trained on domain-specific data, models required for compliance or data residency reasons, or embedding models that outperform defaults for your specific content type — these are legitimate reasons to own the embedding step.

You're implementing advanced retrieval techniques. Hybrid search (combining vector search with keyword search), multi-stage retrieval with custom reranking, or metadata-heavy filtering strategies all require direct access to the vector store layer.

The common thread in all three scenarios: the pipeline detail creates a specific, nameable improvement in retrieval quality or system behavior. That's what I check for before reaching for the Vector Store node.

A practical decision framework

Before choosing, I'd ask one question: what specific user-facing outcome requires custom control over this pipeline step?

If the answer is concrete — "I'm building a legal document search tool where missed clauses have real downstream consequences" — Pinecone Vector Store is worth the investment. If the answer is vague — "I might need more flexibility later" or "I want to understand how it works" — that's not a product requirement, it's technical curiosity. Ship with the Assistant node and revisit when you hit an actual limitation.

The mental shift is from "how do I build this?" to "what am I building?" The Assistant node enables that shift by removing the infrastructure layer as an ongoing concern. When retrieval becomes a managed building block, the interesting engineering work moves up the stack — to routing logic, to evaluation, to the product features that actually differentiate what you're making.

My practical recommendation

For most n8n builders starting a RAG project, I recommend beginning with the Pinecone Assistant node. It handles the pipeline decisions competently, keeps your workflow readable, and gets you to a working system quickly. You can always migrate to a custom pipeline when you identify a specific reason to do so — and that reason will be clearer once you've shipped something and seen where the actual friction is.

Complexity is easy to add later, but you can't get back the time you spend on premature optimization.

Try it out for yourself

Try out the Assistant node with this quickstart or use one of these n8n workflow templates I built to get ideas.

Build a multi-assistant workflow with Pinecone Assistant in n8n

Jenna Pederson — Mon, 16 Feb 2026 15:00:00 +0000

I built an n8n workflow that shows a simple way to use multiple, specialized knowledge bases because sometimes you need knowledge isolation between clients, locations, or even products in your RAG workflows.

Imagine you manage three vacation rental properties. A guest at one of your properties texts asking how to turn on the heat, but you accidentally send them instructions for your other property's completely different thermostat. You look unprofessional, your guest is confused, and now they are cold.

To handle this, we can use multiple specialized Pinecone Assistants in an n8n workflow.

Here's how it works:

Guest sends a question via text/email
Router identifies which property they're asking about
Query gets routed to that property's dedicated assistant
Assistant retrieves the answer from that property's knowledge base (house manual, appliance guides, local recs, WiFi codes)
Guest gets the RIGHT answer for THEIR property

Each property has its own Pinecone Assistant node with its own knowledge base. No mixing. No confusion. No wrong answers.

You need separate assistants when knowledge bases can't be combined:

Multiple vacation properties (different rules, amenities, locations)
Multi-location franchises (different staff, vendors, local procedures)
Agency managing multiple clients (confidential, distinct brand voices)
Any scenario where "close enough" isn't good enough

Copy this url (or the raw json), paste it into a new n8n workflow, and adapt this pattern for your own use case: https://github.com/pinecone-io/n8n-templates/blob/main/vacation-rental-property-manager-assistants/vacation-rental-property-manager-assistants.json

What would you build with this?

Ready for more?

I hope this has been helpful. If it has, please share this with your friends 👯 or drop a comment below 💬. And if you're ready to learn more about building AI workflows in n8n or have suggestions on content that would help you, let me know.

Stay tuned here for more updates or follow along with me on Instagram or LinkedIn where I share short bits of what I'm working on and learning as I go.

Build a simple RAG workflow to chat with your docs in n8n

Jenna Pederson — Fri, 13 Feb 2026 23:00:03 +0000

You know all that RAG complexity you hate? Gone.

For the last few months, I've been exploring how people are using n8n and Pinecone. I discovered that people building RAG workflows in automation tools like n8n have the same frustrations as those building with code in their apps. Choosing a chunking strategy, embedding model, and implementing vector search is hard.

So I started building a ✨new n8n community node for Pinecone Assistant✨

And yesterday, it was launched into the world.

What it does:

Handles the entire RAG pipeline in a single node so you don't have to think about file storage, chunking your data, creating embeddings, query planning, vector search, and reranking.

What you can do:

Connect the Pinecone Assistant node to any n8n node, like Google Drive, Notion, or Slack, and then upload your files, and start querying immediately
Build workflows to chat with your docs, surface insights from your company's proprietary data, or give AI agents accurate context to make better decisions
Go from idea to working RAG workflow in minutes

Now you can focus on building what matters.

To try out the new Pinecone Assistant n8n node:

Create a Pinecone account
Create an Assistant
Import this workflow template by copying this url and pasting it on a new workflow canvas https://raw.githubusercontent.com/pinecone-io/n8n-templates/refs/heads/main/assistant-quickstart/assistant-quickstart.json
Install the Pinecone Assistant node in n8n
Add your credentials to n8n
Run step 1 to upload the documents to Pinecone Assistant
Start chatting with your documents in step 2

Check out the full quickstart here or grab some of the other templates I've created here.

Ready for more?

Stay tuned here for more updates or follow along with me on Instagram or LinkedIn where I share short bits of what I'm working on and learning as I go.

Setting up the Pinecone MCP server in your IDE

Jenna Pederson — Mon, 28 Apr 2025 15:00:00 +0000

Want to prototype and test your Pinecone indexes, right from your IDE?

In this blog post, I'll show you how to avoid the IDE-docs-console-app shuffle by adding the Pinecone Developer MCP server to your IDE. You'll be able to search the official Pinecone docs and create and manage indexes without flipping back and forth between apps.

You'll need a couple bits set up first:

A Pinecone API key
Node.js installed with npm and npx on your path

Add the Pinecone MCP server to your IDE

Let's connect an IDE, in my case Cursor, to the Pinecone MCP server. We'll create an mcp.json file in the .cursor directory, paste in the code below, and replace YOUR_PINECONE_API_KEY with your Pinecone API key.

{
  "mcpServers": {
    "pinecone": {
      "command": "npx",
      "args": [
        "-y", "@pinecone-database/mcp"
      ],
      "env": {
        "PINECONE_API_KEY": "YOUR_PINECONE_API_KEY"
      }
    }
  }
}

Check the config status

We'll now check the config status in Cursor to make sure it is connected to the server and the tools are available. Notice how the connection status turns green when connected.

Add the Pinecone rules for Cursor

Next, we'll add these extra special Pinecone rules for Cursor, to guide it to even better results, making sure it's using the latest stable version of the Pinecone SDK and searches the official docs.

### Tool Usage for Code Generation

- When generating code related to Pinecone, always use the `pinecone` MCP and the `search_docs` tool.

- Perform at least two distinct searches per request using different, relevant questions to ensure comprehensive context is gathered before writing code.

### Error Handling

- If an error occurs while executing Pinecone-related code, immediately invoke the `pinecone` MCP and the `search_docs` tool.

- Search for guidance on the specific error encountered and incorporate any relevant findings into your resolution strategy.

### Syntax and Version Accuracy

- Before writing any code, verify and use the correct syntax for the latest stable version of the Pinecone SDK.

- Prefer official code snippets and examples from documentation over generated or assumed field values.

- Do not fabricate field names, parameter values, or request formats.

### SDK Installation Best Practices

- When providing installation instructions, always reference the current official package name.

- For Pinecone, use `pip install pinecone` not deprecated packages like `pinecone-client`.

You can customize this to your own situation, depending on how you work. I've set mine to Agent Requested and given it a description of Used when generating code related to Pinecone so the agent knows when to include the rule. You can read more about this here.

Try it out

Here's the best part - creating and testing your first Pinecone index right in your IDE. I use this prompt to build an index based on Last of Us storylines:

Create a Pinecone dense index named "pinecone-mcp-demo-dense" that uses `llama-text-embed-v2`. Generate 10 records of test data based on the tv series The Last of Us and their characters and upsert it into the index.

The Cursor agent knows to make the call to the Pinecone MCP server to create the index and then to search records.

This feedback loop lets me quickly iterate on config, test data, and vector search.

And yes, I'm currently watching the Last of Us, so no spoilers!

Now that I've prototyped and tested my index, I can start building my app, using the Pinecone MCP tools to search the docs, manage my test data, all right from my IDE.

Wrapping up

If you'd like to check out how to configure the Pinecone MCP server with other IDEs, check out this guide.

I hope this has been helpful! If you have feedback or want to share how you're using the Pinecone MCP server in your development workflow, drop a note in the comments.

A conversation with your architecture

Jenna Pederson — Wed, 18 Dec 2024 18:00:00 +0000

Over the course of my career I have worked on a number of sprawling software systems. One tool that has been invaluable during my time as a software engineer is the use of software and architecture diagrams. But one pain point I always have with diagrams is that they are almost always complex, with a lot of detail, and coming into an existing system I need to be able to get up to speed quickly. In this article, I will show you the value of software and architecture diagrams, challenges we face with them, and how I’m using generative AI to better understand diagrams, gain deeper insights, make decisions, generate diagrams, and even generate infrastructure code.

Let’s get started.

Why diagrams are important

Software and architecture diagrams are critical tools as they help developers and stakeholders understand complex systems.

A diagram can help bridge the gap between technical and non-technical stakeholders. With a common visual language, a diagram can communicate complex relationships and details better than pages of text can. They can help us see the big picture so we can better understand how various parts of a system work together or what will be impacted with changes.

All of this helps us plan for the future, identify risks and dependencies, and make informed decisions.

Different types of diagrams also have different purposes. With class diagrams you have a blueprint for implementation and can visualize inheritance and composition relationships better. Sequence diagrams help you understand the flow and how objects interact over time.

Together, the various types of diagrams give a comprehensive view of a system. But they can also pose some challenges

Challenges with diagrams

There are a number of challenges with software and architecture diagrams but a couple that are top of mind for me are how quickly they can become complex and how easily they become out of date.

It’s important to make sure your diagram has the right level of detail for its purpose and audience. Too much detail and they become overwhelming. Too little detail and you don’t have the right information to make a decision. It is a fine balance and takes practice.

Diagrams are also as of a point in time and if they are not maintained over time, they won’t reflect reality, making it harder to get accurate insights and make decisions.

There are approaches and tools to manage some of these challenges but today I want to show how using generative AI can help you to better understand diagrams, gain deeper insights, make decisions, generate diagrams, and even generate infrastructure code.

Let's have a conversation with our architecture

What if we could have a conversation with our diagrams? What if we could understand it quicker, get custom recommendations for our system, use real-time data and best practices from our company, and even generate new and updated diagrams?

We can.

I’m going to show you how using a demo app I built with Python using the Amazon Bedrock Converse API. This will let us carry out a conversation, back and forth, between a large language model and the user. We’ll incorporate tool use to get access to real-time data and a knowledge base to pull in data from our company’s custom best practices.

Try it yourself

If you’d like to grab the code and run through this yourself with your own diagram or see how it was implemented, you can get it here. Clone the repo, make sure you're set up with an AWS account, have access to the Claude Sonnet 2.5 model on Amazon Bedrock, and have Python 3.10.16 or later installed.

A simple serverless example

We’ll start with this diagram that visualizes a simple serverless application that generates joy from fluffy puppy memes. Very important business!

This app runs at the command line. Once we’ve started it up, we enter the diagram we want to analyze and our first query:

List the AWS Services used in the architecture diagram by official AWS name and excluding any sub-titles.

And the output:

Certainly! I'll analyze the architecture diagram in the image "demo/fluffy-puppy-joy-generator.png" and list the AWS services used by their official AWS names, excluding any subtitles. Here's the list:

1. Amazon S3 (Simple Storage Service)
2. Amazon Rekognition
3. AWS Lambda
4. Amazon CloudFront

These are the four distinct AWS services that are clearly identifiable in the architecture diagram for the Fluffy Puppy Joy Generator application.

We could then ask follow up questions like:

What are the recommended strategies for unit testing this architecture?
How well does this architecture adhere to the AWS Well Architected Framework?
What improvements should be made to the resiliency of this architecture?
Convert the data flow from this architecture into a Mermaid formatted sequence diagram.
What are the quotas or limits in this architecture?
Can you generate the CloudFormation code to provision this architecture?

This approach uses the Amazon Bedrock Converse API to have a conversation with an LLM. This API maintains the chat history as context for the future conversation. You can read more about how this works in my past blog post here. This conversation is limited to the training data for the model we have selected (in this case, Claude Sonnet 3.5).

Retrieving real-time data with a tool

But what if we wanted to ask more specific questions about this system? For instance, what if we wanted to know how much joy is being generated by this system? We could ask:

What is the joy count of the current system?

In order to support questions like this that get at real-time data, we'll need to use a tool with Amazon Bedrock. In this app, we have a tool called joy_count_tool.py that can retrieve the current, up-to-date joy count from the system via an API (our implementation retrieves it from a JSON file for simplicity). During the conversation, the model detects that a tool is needed, replies back to our app with which specific tool to use, and then our app uses the tool to retrieve the joy count. This data is then passed back to the model and a natural language response incorporating the joy count is returned to our app. You can read more about how tool use works with Amazon Bedrock in my past blog post here.

Incorporating custom data with an Amazon Bedrock Knowledge Base

Knowing the joy count is helpful, but how do we even know if this number is good or bad? How do we know if it adheres to our company's best practices? We could ask:

Is a joy count of 189 good or bad?

With an output:

Thank you for providing that information. Now I can assess whether the current joy count is good or bad based on the company's best practices.

According to the best practices for the Fluffy Puppy Joy Generator system, the joy count is evaluated on the following scale:

- Joy Count 1-100: Bad
- Joy Count 101-200: OK
- Joy Count 201-300: Good
- Joy Count 301-400: Better
- Joy Count 401+: Best

The current joy count of 189 falls within the "OK" range (101-200). This means that the application is generating some joy, but there is still room for improvement. 

To elaborate:

1. The system is performing adequately, as it's not in the "Bad" category.
2. However, it hasn't yet reached the "Good" level, which starts at 201.
3. There's significant potential for enhancement to move into the higher categories.

The best practices suggest that when the joy count is in this range, more work is required to improve the experience. This could involve:

1. Refining the meme generation algorithms
2. Improving content selection
3. Optimizing distribution strategies

To boost the joy count and move into the "Good" or better categories, the team should focus on these areas of improvement. Regular reviews of the joy count and implementing updates to the system components are recommended to maintain and increase the level of joy generation.

In summary, while the current joy count of 189 is not bad, it indicates that the Fluffy Puppy Joy Generator has room for improvement to reach its full potential in spreading puppy-related joy to users.

To support a question like this, we use an Amazon Bedrock Knowledge Base to provide contextual information to the model. In this case, we have a knowledge base using an Amazon S3 bucket as a data source. This bucket contains data about our company's best practices. We use the Amazon Titan Text Embeddings v2 model with an Amazon OpenSearch Serverless vector store. You can read more about setting up an Amazon Bedrock Knowledge Base in my coworker's blog post here.

This may be a trivial example, but this means we can bring real-time data into our app and gather insights based on our own internal data, like our company's best practices or policies and then generate a natural language response incorporating that data. Then we could ask questions like:

Are all our AWS resources properly configured according to our company's compliance requirements?
Does this architecture adhere to our company best practices?
Does this class diagram adhere to our naming best practices?
Where are the current bottlenecks in this system?

Again, the Fluffy Puppy Joy Generator is only a trivial example but using generative AI as another tool in our toolbox with diagrams opens up more possibilities for visualizing our systems, making decisions, implementation, and getting customers using our software earlier.

Where we go from here

Now that we’ve covered how generative AI can help with these challenges, I want to leave you with some hands-on assets to work with your own architecture diagrams.

Get the code, tweak it to your use case or analyze your own diagram here.
Work through the workshop, Harnessing generative AI to create and understand architecture diagrams that I co-led at re:Invent 2024.
Read how Olivier Lemaitre, AWS User Group leader, goes from diagram to code with Amazon Q Developer.

I hope this has been helpful. If you'd like more like this, smash that like button 👍, share this with your friends 👯, or drop a comment below 💬 about how you're using generative AI with diagrams. You can also find my other content like this on Instagram, LinkedIn, and YouTube.

What I learned while building my first game

Jenna Pederson — Tue, 05 Nov 2024 13:00:00 +0000

This post was inspired by the AWS Game Builder Challenge. Create a game with AWS services of your choosing: all skill levels welcome!

My family is a game family. Board games, murder mystery party games, escape rooms, game shows, game nights. One of my favorite game shows is Password and I used it as inspiration to create the Cloud Password Game for the AWS Game Builder Challenge running through the month of November.

In this blog post, I'm going to share about building the game and what I learned along the way. Just want the code? Grab it here.

Let's check it out!

The game

With the Cloud Password Game, I wanted to test my own cloud and AWS knowledge and I wanted to do that by presenting a secret word, known as the password, and offering one-word clues to guess that password. For every password you guess correctly, you get a point.

Building the game

This game is built and deployed with AWS Amplify and uses the Amazon Bedrock Converse API to generate the password and clues. I'm not going to cover every step for getting this set up and deployed with Amplify because there is a fantastic getting started guide. I’ve also showed how to use the Amazon Bedrock Converse API in past blog posts so we won't go into that detail here.

But I am using a new (to me) model, the Amazon Titan Text G1 - Premier model, and this required me to learn more about prompt engineering for Titan text models.

Prompt engineering

I quickly discovered there is no support for a system prompt when using the Titan text models, but in talking with my coworkers about this, I learned that's actually ok. I can incorporate that context into the user prompt instead. I started digging through the Amazon Titan Text models documentation and discovered this helpful prompt engineering guide specifically for Titan text models.

Building the initial prompt

I started with a persona, an expert AWS and cloud word game show host and set the stage for the conversation between user and bot.

Act like you are an expert AWS and cloud word game show host who generates a secret word and one-word clues to guess that word. The user will only respond with a guess.

Next, I added specific instructions in bulleted list format:

Instructions:
- The secret word should be 1-4 words long
- The secret word should be based on AWS service names
- Do NOT obfuscate the secret word in the output
- The clues you generate will represent the secret word
- The clues MUST be only one word long
- The clues should start out difficult and get increasingly easier over time
- You MUST ONLY share one clue at a time
- ALWAYS generate a new, unique clue
- NEVER generate a clue that is one of the past guesses
- Generate a clue during every interaction
- You MUST answer in JSON format only
- DO NOT use any other format while answering the question
- DO NOT include any additional explanation or information in the JSON output or after the JSON output

I included the rules around how to generate both the secret word and the clues and how to respond, in JSON format only. I've added some emphasis for some words like MUST, NEVER, DO NOT so that the model will strictly obey.

Notice that I also referred to the password as secret word throughout this prompt. I found that there was a lot of confusion about this being a real password that couldn't be revealed for security reasons and so that's why there is an instruction to not obfuscate the secret word and no reference to the word password. Clear, concise, and specific it is!

Then, I added more detail on how to format the output. In addition to the instructions above about formatting the output in JSON, I also included the specific output format so that I could parse it on the other end.

Please follow the output schema as shared below.
Output Schema:
{
  “word”: "the secret word to guess",
  “clue”: "clue1"
}

I also added an example of what I expect:

Example:
{
  “word”: “AWS”,
  “clue”: “cloud"
}

One road bump I ran into with the output format and example were that in the prompt engineering guide linked above, it showed the JSON format with backticks, which I understood to mean I should also include them. This created chaos, with the model responding with extra explanations and context AFTER the JSON output I tried to ask for. It took a long while to discover this issue, but once I removed this everything was hunky dory.

```json
{{json content}}
```

And then the final ask:

Generate the secret word and the first clue.

One of the strategies in the prompt engineering guide linked above was to use User: and Bot: to indicate the turn-by-turn conversation flow. I experimented with this early on as I was building this prompt and the model often got confused on what needed to happen next. I suspect this was because I didn't have specific enough instructions early on. I may revisit this in a future version but for now, this works and you can see the final prompt below.

My final prompt

Here is the final prompt to initialize the game with a password and the first clue:

Act like you are an expert AWS and cloud word game show host who generates a secret word and one-word clues to guess that word. The user will only respond with a guess.

Follow the instructions when responding.
Instructions:
- The secret word should be 1-4 words long
- The secret word should be based on AWS service names
- Do NOT obfuscate the secret word in the output
- The clues you generate will represent the secret word
- The clues MUST be only one word long
- The clues should start out difficult and get increasingly easier over time
- You MUST ONLY share one clue at a time
- ALWAYS generate a new, unique clue
- NEVER generate a clue that is one of the past guesses
- Generate a clue during every interaction
- You MUST answer in JSON format only
- DO NOT use any other format while answering the question
- DO NOT include any additional explanation or information in the JSON output or after the JSON output

Please follow the output schema as shared below.
Output Schema:
{
  “word”: "the secret word to guess",
  “clue”: "clue1"
}

Example:
{
  “word”: “AWS”,
  “clue”: “cloud"
}

Generate the secret word and the first clue.

Then I used this follow up prompt when submitting a guess:

My guess is: {guess}

Generate the next clue. DO NOT change the secret word. DO NOT use any of the past clues.

Here I gave it some context (the guess) and the instructions. Sometimes the secret word was changing and occasionally past clues were being reused, so I added a nice little reminder.

Next, I had to code this up in my web app.

Assistance while coding

As I mentioned earlier, I used AWS Amplify and the Amazon Bedrock Converse API to implement this game. As we all do, I ran into road bumps as I wrote my code and I want to share how I handled them. I've written before about my experience using generative AI and more specifically Amazon Q Developer to support my development workflow (here, here, here, and here). While I used those tools throughout building this app, what I found most interesting was a new addition to Amazon Q Developer: the CMD+i keyboard shortcut, also known as inline chat.

During my coding, I often run up against a question about syntax, how to express some logic in a simple way, want to refactor a block of code, or generate a small snippet of code. Normally, I just forge ahead or more recently I would head over to the Amazon Q Developer chat pane and type out my query, and then copy/paste the results. But while I was building this app out, I used inline chat to assist me. I simplified blocks of code, figured out how to compare the lowercased version of two string values (because apparently my IDE was flagging what I originally wrote as incorrect), printed out the entire contents of the conversation variable to the console, and made an interpolated string compile. I really did ask "How can I make this compile?" and it gave me an updated version. Turns out there were a bunch of back ticks that needed to be escaped.

Here's how inline chat works:

Select the block of code you want to work with
Press ⌘ + i on Mac or Ctrl + i on Windows, in VSCode or JetBrains
Type out your prompt and press Enter
Amazon Q Developer will generate a diff inline with your existing code that you can accept or reject.

Here's what it looks like after selecting the code and triggering the inline chat:

And then to accept/reject the suggestion:

What's really nice here is that I don't have to flip back and forth between the Amazon Q Developer chat pane and my code, copying over updated code snippets. I get to stay right in the text editor pane as I type out my code. This functionality shines with code updates (like refactoring or helping fix a bug in a block of code), but it also supports code additions, too.

Check out more uses cases here on how inline chat works.

For the future

This isn't perfect and there are definitely improvements we could make for the future. Here's what I might think about for next time:

Adding authentication (set up Amplify Auth with Cognito here)
A leaderboard to track scores against other users
Refining the prompt for better passwords and clues
Updating the UI (it's pretty basic)

Wrapping up

In this post, you learned about how to craft a prompt for the Amazon Titan Text models, how to use Amazon Q Developer's new inline chat feature. You can grab the code for this game app here.

The AWS Game Builder Challenge runs through November and you can build your own game. Check out the details of the hackathon here.

Haven't tried Amazon Q Developer yet? Get started with a Builder ID here.

I hope this has been helpful. If you'd like more like this, smash that like button 👍, share this with your friends 👯, or drop a comment below 💬. You can also find my other content like this on Instagram and YouTube.

Bridging AI and real-time data with tools

Jenna Pederson — Wed, 02 Oct 2024 19:03:00 +0000

Have you ever wondered why you can chat with an LLM about how to solve math problems but they struggle with actual mathematical calculations? Or why they cannot reliably provide up to date information? LLMs are trained on text and they learn to predict patterns in that text. They don't have a built in calculator, so they can only approximate based on patterns they've seen, leading to errors especially with large numbers or complex calculations. The text they're trained on is also at a point in time, so asking about the current weather or today's stock prices would only be as current as the training data.

Many times, though, we'll need to augment LLM responses with real-time data from external tools and APIs. One way we can do this, is using an LLM feature called tool use (or function calling) to give them their own set of tools to use. Tool use can be applied to fetch real-time data from a database or inventory system, stock prices, weather forecasts, or even your cloud resources.

In this blog post, I'm going to show you how to integrate fetching real-time data from a weather API so you can interact with real-time data using natural language. We'll implement this in Python and using Amazon Bedrock's Converse API, we'll define a tool for our AI to use when requested. This creates a seamless interaction between AI and a custom function, allowing us to combine the strengths of both.

Let's get started!

Prerequisites

To work through this example, you'll need a few bits set up first:

An AWS account. You can create your account here.
Request access to an AI model (we'll use Claude Sonnet) on Amazon Bedrock before you can use it. Learn about model access here.
Python 3.6.0 or later setup and configured on your system.
A python virtual environment setup with packages installed via requirements.txt. Read more about doing this here.

Just want the code? Grab it here.

1. Setup

First, we'll set up the system prompt and the tool configuration for our tool.

The system prompt tells the model that it should use a tool in a specific situation -- when providing current weather data, use the Weather_Tool.

#
# Step 1: Define system prompt that requires the use of the tool
#
SYSTEM_PROMPT = """
You are a weather assistant that provides current weather data for user-specified locations using only
the Weather_Tool, which expects latitude and longitude. Infer the coordinates from the location yourself.
If the user provides coordinates, infer the approximate location and refer to it in your response.
To use the tool, you strictly apply the provided tool specification.

- Explain your step-by-step process, and give brief updates before each step.
- Only use the Weather_Tool for data. Never guess or make up information. 
- Repeat the tool use for subsequent requests if necessary.
- If the tool errors, apologize, explain weather is unavailable, and suggest other options.
- Report temperatures in °C (°F) and wind in km/h (mph). Keep weather reports concise. Sparingly use
  emojis where appropriate.
- Only respond to weather queries. Remind off-topic users of your purpose. 
- Never claim to search online, access external data, or use tools besides Weather_Tool.
- Complete the entire process until you have all required data before sending the complete response.
"""

Then we define the specification for our weather tool using the Converse API tool definition format. We describe the weather tool and defining the inputs so that the model knows how to interact with it. In this case, the tool expects a latitude and longitude of a location.

#
# Step 2: Define weather tool using the Converse API tool definition format
#
WEATHER_TOOL_SPEC = {
    "toolSpec": {
        "name": "Weather_Tool",
        "description": "Get the current weather for a given location, based on its WGS84 coordinates.",
        "inputSchema": {
            "json": {
                "type": "object",
                "properties": {
                    "latitude": {
                        "type": "string",
                        "description": "Geographical WGS84 latitude of the location.",
                    },
                    "longitude": {
                        "type": "string",
                        "description": "Geographical WGS84 longitude of the location.",
                    },
                },
                "required": ["latitude", "longitude"],
            }
        },
    }
}

2. Implement the tool

Next, we'll implement the tool. This is where we'll make an API call to the Open-Meteo API to retrieve the current weather for a given location.

#
# Step 3: Implement the weather tool function
#
def fetch_weather_data(input_data):
    """
    Fetches weather data for the given latitude and longitude using the Open-Meteo API.
    Returns the weather data or an error message if the request fails.

    :param input_data: The input data containing the latitude and longitude.
    :return: The weather data or an error message.
    """
    endpoint = "https://api.open-meteo.com/v1/forecast"
    latitude = input_data.get("latitude")
    longitude = input_data.get("longitude", "")
    params = {"latitude": latitude, "longitude": longitude, "current_weather": True}

    try:
        response = requests.get(endpoint, params=params)
        weather_data = {"weather_data": response.json()}
        response.raise_for_status()
        return weather_data
    except RequestException as e:
        return e.response.json()
    except Exception as e:
        return {"error": type(e), "message": str(e)}

3. Send conversation to Amazon Bedrock

To send the conversation to Amazon Bedrock, we first create a conversation array with our initial user prompt. In the example code repo, you can see how you might collect this directly from the user interactively.

#
# Step 4: Define the initial message and conversation
#
conversation = []
initial_message = {
    "role": "user",
    "content": [
        { "text": "What is the current weather in Minneapolis, MN?" }
    ],
}
conversation.append(initial_message)

Then, we make the converse call, sending along the model, conversation, tool config, and our system prompt.

#
# Step 5: Send the message with the tool config and system prompt
#
response = bedrock.converse(
    modelId=MODEL_ID,
    messages=conversation,
    inferenceConfig={
        "maxTokens": 2000,
        "temperature": 0
    },
    toolConfig={
        "tools": [WEATHER_TOOL_SPEC]
    },
    system=[{"text": SYSTEM_PROMPT}]
)

4. Process the response and call the tool

Once we have a response from Amazon Bedrock, we have to process the response. We'll check to see if a tool is being requested (toolUse is returned) and if so, we call the requested tool.

With a result from the tool, the fetch_weather_data function, we then prepare a toolResult to send back to Amazon Bedrock for further processing.

#
# Step 6: Process the response and call the tool when requested
#
response_message = response['output']['message']
conversation.append(response_message)
response_content_blocks = response_message['content']

follow_up_content_blocks = []

for content_block in response_content_blocks:
    if 'text' in content_block:
      print(content_block['text'])
    elif 'toolUse' in content_block:
      tool_use_block = content_block['toolUse']
      tool_use_name = tool_use_block['name']

      if tool_use_name == 'Weather_Tool':
        tool_result_value = fetch_weather_data(tool_use_block['input'])

        follow_up_content_blocks.append({
            "toolResult": {
                "toolUseId": tool_use_block['toolUseId'],
                "content": [
                    {
                        "json": {
                            "result": tool_result_value
                        }
                    }
                ]
            }
        })
      # Handle unknown tools
      else:
        follow_up_content_blocks.append({
          "toolResult": {
            "toolUseId": tool_use_block['toolUseId'],
            "content": [
                {
                    "text": "unknown tool" + tool_use_name
                }
            ],
            "status": "error"
          }
        })

5. Send the tool result back to Amazon Bedrock

With the toolResult containing the current weather data, we now send this to Amazon Bedrock so we can get the final natural language response from the model incorporating the tool result -- the current weather.

#
# Step 7: Send tool result back to Amazon Bedrock
#
if len(follow_up_content_blocks) > 0:

    follow_up_message = {
        "role": "user",
        "content": follow_up_content_blocks,
    }

    conversation.append(follow_up_message)

    response = bedrock.converse(
        modelId=MODEL_ID,
        messages=conversation,
        inferenceConfig={
            "maxTokens": 2000,
            "temperature": 0
        },
        toolConfig={
            "tools": [WEATHER_TOOL_SPEC]
        },
        system=[{"text": SYSTEM_PROMPT}]
    )

    response_message = response['output']['message']
    print(response_message['content'][0]['text'])
    conversation.append(response_message)

Run the code

Finally, we're ready to run the code and find the current weather for a location through natural language conversations. Run the following at the command line or in your IDE:

python weather_tool_use_demo.py

The output we get is:

Okay, let me check the current weather conditions for Minneapolis, MN using the Weather Tool.

First, I'll need to get the latitude and longitude coordinates for Minneapolis:
Minneapolis, MN coordinates: 44.9778°N, 93.2650°W

Next, I'll invoke the Weather Tool with those coordinates:
Here is the current weather report for Minneapolis, MN:

The temperature is 17.9°C (64.2°F) with a partly cloudy sky. Winds are blowing from the west-northwest at 19.8 km/h (12.3 mph). ☁️ 🍃

Let me know if you need any other weather details for Minneapolis!

Wrapping up

In this post, you learned why LLMs struggle to make complex calculations and provide real-time information. I showed one approach for augmenting your LLM responses with data from external tools and APIs -- tool use (or function calling). Then, I showed how to implement this in Python with Amazon Bedrock's Converse API.

Other helpful resources

I hope this has been helpful. If you'd like more like this, smash that like button 👍, share this with your friends 👯, or drop a comment below 💬.

Telling bedtime stories with generative AI

Jenna Pederson — Thu, 15 Aug 2024 13:00:00 +0000

I read to my kid a lot. To be clear, I read one or two books a lot to my kid. To the point that I have the words to both books memorized. What if we could create our own story, together, to tell a new story each night with new characters? In this article, I will show how we can use an AI chat integration and customize it to act as an interactive bedtime storyteller. With this approach, you could build a personalized meal planner, a travel guide, or an assistant to help you ideate and refine your social media copy.

Let's first check out the high-level solution.

Our solution

I'm working within a React app built and deployed with AWS Amplify. If you'd like to start here, you can spin up the sample app using this quickstart guide and then incorporate the code I share.

We'll use Amazon Bedrock as a datasource and make a custom query to generate a story using the new Converse API. The Converse API will allow us to handle multi-turn conversations and maintain a conversation history. We'll go a step further, utilizing the systemPrompt feature to provide context, instructions, and guidelines on how it should respond.

The example code below is Typescript, but you can also find sample code for other languages here.

Let's get started building!

Add a data source

Our first task is to add Amazon Bedrock as a data source to our app. This approach gives an AWS Lambda function (we'll define that in the next step) permission to call a specific foundation model in Amazon Bedrock. We're limiting the actions it can make to bedrock:InvokeModel and the specific model resource we specify.

To do this, let's add the following to the amplify/backend.ts file:

// amplify/backend.ts
import { defineBackend } from '@aws-amplify/backend';
import { auth } from './auth/resource';
import { data, CHAT_MODEL_ID, generateChatResponseFunction } from './data/resource';
import { Effect, PolicyStatement } from 'aws-cdk-lib/aws-iam';

export const backend = defineBackend({
  auth,
  data,
  generateChatResponseFunction,
});

backend.generateChatResponseFunction.resources.lambda.addToRolePolicy(
  new PolicyStatement({
    effect: Effect.ALLOW,
    actions: ["bedrock:InvokeModel"],
    resources: [
      `arn:aws:bedrock:*::foundation-model/${CHAT_MODEL_ID}`,
    ],
  })
);

Next, we need to define the custom query and connect it to the handler function that will make the call to Amazon Bedrock.

Define a custom query

In this step, we first define the generateChatResponseFunction using defineFunction and configure it with the model id, timeout, and which Node runtime top use. The entry key will specify the handler that with the core logic.

Now, we define a custom query generateChatResponse and add it to the schema. Here, we define the arguments allowed, the return type, and which function to use.

To do this, update the amplify/data/resource.ts file like this:

// amplify/data/resource.ts
import { type ClientSchema, a, defineData, defineFunction } from "@aws-amplify/backend";

export const CHAT_MODEL_ID = "anthropic.claude-3-sonnet-20240229-v1:0";

export const generateChatResponseFunction = defineFunction({
  entry: "./generateChatResponse.ts",
  environment: {
    CHAT_MODEL_ID,
  },
  timeoutSeconds: 180,
  runtime: 20
});

const schema = a.schema({
  generateChatResponse: a
    .query()
    .arguments({ conversation: a.json().required(), systemPrompt: a.string().required() })
    .returns(a.string())
    .authorization((allow) => [allow.publicApiKey()])
    .handler(a.handler.function(generateChatResponseFunction)),
});

export type Schema = ClientSchema<typeof schema>;

export const data = defineData({
  schema,
  authorizationModes: {
    defaultAuthorizationMode: "apiKey",
    apiKeyAuthorizationMode: {
      expiresInDays: 30,
    },
  },
});

In the code above, the first argument is a JSON string, conversation. This will include the entire conversation from our interactions with our interactive storyteller.

The second argument is a string, systemPrompt. We'll use this to customize our interactions with the model, by providing context, instructions, and guidelines on how to respond.

Create the handler code

Next, we'll create the handler code with our core logic that makes the call to Amazon Bedrock. Here, we'll initialize the BedrockRuntimeClient, prepare the input and conversation as a ConverseCommandInput, and then make the call.

When this handler code is called, the conversation argument will be passed a JSON string representing the full conversation between the user and the interactive story teller. This is then parsed and loaded as an object with this structure:

[
  {
    role: "user",
    content: [{ text: firstUserMessage }]
  },
  {
    role: "assistant",
    content: [{ text: firstResponseMessage }]
  },
  {
    role: "user",
    content: [{ text: secondUserMessage }]
  }
]

This allows us to maintain a conversation history and handle multi-turn conversations.

To implement this, create the amplify/data/generateChatResponse.ts file with the code below:

// amplify/data/generateChatResponse.ts
import type { Schema } from "./resource";
import {
  BedrockRuntimeClient,
  ConverseCommand,
  ConverseCommandInput,
} from "@aws-sdk/client-bedrock-runtime";

const client = new BedrockRuntimeClient();

export const handler: Schema["generateChatResponse"]["functionHandler"] = async (
  event
) => {

  const conversation = event.arguments.conversation;
  // System prompt for context
  const systemPrompt = [{text: event.arguments.systemPrompt}];

  const input = {
    modelId: process.env.CHAT_MODEL_ID,
    system: systemPrompt,
    messages: conversation,
    inferenceConfig: {
      maxTokens: 1000,
      temperature: 0.5,
    }
  } as ConverseCommandInput;

  const command = new ConverseCommand(input);
  const response = await client.send(command);

  const jsonResponse = JSON.stringify(response.output?.message);

  return jsonResponse;
};

The maxTokens inference parameter defines the maximum number of tokens the model can generate and temperature controls how creative it can get (a number between 0 and 1 with closer to 1 being more creative). Read more about these inference parameters here.

Create the component to facilitate the conversation

Our last big step is creating the component that makes the function call via the custom query. This component will facilitate the conversation between the user and the interactive story teller. Here's what our component will look like:

Below, I'll cover the major parts of the ChatComponent.tsx and how each part works, and then I'll share the full code (jump to [here] if that's all you're looking for).

In the JSX portion of ChatComponent.tsx, we iterate over the conversation between the AI (labeled assistant here) and the user (labeled human). The conversation alternates between the assistant and human, so we style each a little different.

We add a TextField component to capture the user's message, setting the inputValue via handleInputChange when text is entered and calling setNewUserMessage whenever the Enter key is pressed or the Send button is pressed. There are also properties to show an error message if one exists.

<View width="60vw">
  <Flex direction="column" wrap="wrap" justifyContent="space-between">
    {conversation.map((item, i) => item.role === "assistant" ? (
      <Message width="40vw" className="assistant-message" colorTheme="neutral" key={i}>{item.content[0].text}</Message>
    ) : (
      <Message width="40vw" className="human-message" hasIcon={false} colorTheme="info" key={i}>{item.content[0].text}</Message>
    ))}
    {isLoading ? (<Loader />) : (<div></div>)}
    <TextField label="What would you like to chat about?"
      name="prompt"
      value={inputValue}
      onChange={handleInputChange}
      onKeyUp={(event) => {
        if (event.key === 'Enter') {
          setNewUserMessage();
        }
      }}
      labelHidden={true}
      hasError={error !== ""}
      errorMessage={error}
      width="60vw"
      outerEndComponent={<Button onClick={setNewUserMessage}>Send</Button>} />
  </Flex>
</View>

We'll use a simple handleInputChange function that clears the error if there was one whenever the user starts typing and then sets the input value.

const handleInputChange = (e: ChangeEvent<HTMLInputElement>) => {
    setError("");
    setInputValue(e.target.value);
};

Next, we'll implement setNewUserMessage to add the new message from the human (using the role user) to the conversation. This is in the same structure as we covered earlier, alternating between user and assistant roles.

const setNewUserMessage = async () => {
    const newUserMessage = { role: "user", content: [{ text: inputValue }] };
    setConversation(prevConversation => [...prevConversation, newUserMessage]);
};

Now it's time to make the call to the generateChatResponse query to send the message to the model with Amazon Bedrock. We use the useEffect hook because we need to wait on setConversation to be complete before making the call. We implement fetchChatResponse as an async function to make the actual call and only call it when there is a conversation where the last message is from the user. We do this last check because we only want to send user messages to the model. We do not want to send the assistant's responses, which we also push back onto the conversation (remember that alternating user-assistant conversation array from earlier?) so the model has our entire conversation history as context.

useEffect(() => {
    const fetchChatResponse = async () => {
        setInputValue('');
        setIsLoading(true);

        const { data, errors } = await client.queries.generateChatResponse({
            conversation: JSON.stringify(conversation),
            systemPrompt: systemPrompt
        });

        if (!errors && data) {
            setConversation(prevConversation => [...prevConversation, JSON.parse(data)]);
        } else {
            setError(errors?.[0].message || "An unknown error occurred.")
            console.error("errors", errors);
        }
            setIsLoading(false);
        }

    // only fetch the response if there is a conversation and it ends with a user role message
    if (conversation.length > 0 && conversation[conversation.length - 1].role === "user") {
        fetchChatResponse();
    }

}, [conversation]);

Full code for the component

Here is the full code for the component:

// ChatComponent.tsx
import { ChangeEvent, useState, useEffect } from "react";
import { Button, Flex, Loader, TextField, View, Message } from "@aws-amplify/ui-react";
import { generateClient } from "aws-amplify/api";
import { Schema } from "../../../amplify/data/resource";
import "./chat.css"

const client = generateClient<Schema>();

export default function ChatComponent({systemPrompt} : { systemPrompt: string}) {
  const [conversation, setConversation] = useState<{ role: string, content: { text: string }[] }[]>([]);
  const [inputValue, setInputValue] = useState("");
  const [error, setError] = useState("");
  const [isLoading, setIsLoading] = useState(false);

  const handleInputChange = (e: ChangeEvent<HTMLInputElement>) => {
    setError("");
    setInputValue(e.target.value);
  };

  useEffect(() => {
    const fetchChatResponse = async () => {
      setInputValue('');
      setIsLoading(true);

      const { data, errors } = await client.queries.generateChatResponse({
        conversation: JSON.stringify(conversation),
        systemPrompt: systemPrompt
      });

      if (!errors && data) {
        setConversation(prevConversation => [...prevConversation, JSON.parse(data)]);
      } else {
        setError(errors?.[0].message || "An unknown error occurred.")
        console.error("errors", errors);
      }
      setIsLoading(false);
    }

    // only fetch the response if there is a conversation and it ends with a user role message
    if (conversation.length > 0 && conversation[conversation.length - 1].role === "user") {
      fetchChatResponse();
    }

  }, [conversation]);

  const setNewUserMessage = async () => {
    const newUserMessage = { role: "user", content: [{ text: inputValue }] };
    setConversation(prevConversation => [...prevConversation, newUserMessage]);
  };

  return (
    <View width="60vw">
      <Flex direction="column" wrap="wrap" justifyContent="space-between">
        {conversation.map((item, i) => item.role === "assistant" ? (
          <Message width="40vw" className="assistant-message" colorTheme="neutral" key={i}>{item.content[0].text}</Message>
        ) : (
          <Message width="40vw" className="human-message" hasIcon={false} colorTheme="info" key={i}>{item.content[0].text}</Message>
        ))}
        {isLoading ? (<Loader />) : (<div></div>)}
        <TextField label="What would you like to chat about?"
          name="prompt"
          value={inputValue}
          onChange={handleInputChange}
          onKeyUp={(event) => {
            if (event.key === 'Enter') {
              setNewUserMessage();
            }
          }}
          labelHidden={true}
          hasError={error !== ""}
          errorMessage={error}
          width="60vw"
          outerEndComponent={<Button onClick={setNewUserMessage}>Send</Button>} />
      </Flex>
    </View>
  )
}

And to style the human-assistant messages:

/* chat.css */
.assistant-message {
  margin-right: auto;
}

.human-message {
  margin-left: auto;
}

Putting it all together

Now we have our backend code - the custom query with a handler backed by a Lambda function that makes the call to Amazon Bedrock. And our chat component - a React component that displays the full chat conversation between human and AI assistant with a text field to collect the human's next message.

We'll add the following to our App.tsx file:

// App.tsx
<View as="section">
    <Heading
        width='60vw'
        level={2}>      
        Let's tell a story together.
    </Heading>
    <Text
        variation="primary"
        as="p"
        lineHeight="1.5em"
        fontWeight={400}
        fontSize="1em"
        fontStyle="normal"
        textDecoration="none"
        width="60vw">
        Start by introducing yourself and saying hi.
    </Text>
    <Chat
        systemPrompt={ "Pretend you are an author of a choose your own adventure style story for children age 3-5. Start by asking the user a series of three questions to understand the theme of the adventure. Tell the first part of four parts of the story and then ask the user to make a choice about the path they would like to take. Repeat this until all for parts of the story are complete. Each part is 2-4 paragraphs long." }
    />
</View>

To make this customized to our use case -- interactive bedtime storyteller -- we set the systemPrompt to:

Pretend you are an author of a choose your own adventure style story for children age 3-5. Start by asking the user a series of three questions to understand the theme of the adventure. Tell the first part of four parts of the story and then ask the user to make a choice about the path they would like to take. Repeat this until all for parts of the story are complete. Each part is 2-4 paragraphs long.

You can customize this to your own use case so that your assistant has context, instructions, and guidelines on how to respond to your user.

Additionally, you may also want to update the CHAT_MODEL_ID in amplify/data/resource.ts to use a different model that works for your use case. You can find supported Amazon Bedrock models here.

Wrapping up

And that's it! In this article, we used the interactive bedtime storyteller use case to show how to integrate the Amazon Bedrock Converse API into your Amplify (Gen 2) app, how to send the full conversation to maintain a history and handle multi-turn conversations, and how to use the systemPrompt and inference parameters, maxTokens and temperature, to customize the assistant even more. To explore more ways to use Amazon Bedrock, check out these code samples in various languages.

I hope this has been helpful. If you'd like more like this, smash that like button 👍, share this with your friends 👯, or drop a comment below 💬.

How an AI coding companion keeps my code DRY

Jenna Pederson — Thu, 18 Jul 2024 14:00:00 +0000

One of the challenges with working in a large code base is that you have remember all the things: coding styles, best practices, your own company's patterns, your custom libraries and their APIs. If you aren't able to memorize it all (because most people can't), you're left digging through code or docs trying to figure it out, relying on tools to remind you about styles, or using pre-commit hooks to fix issues for you. Maybe you're waiting for that dreaded code review. They're either going to remind you that you're not using the established pattern and you have more work to do. Or they'll drop a comment in the pull request "LGTM" and merge it with barely a glance and then bugs are found later in production.

Instead of relying on that that grumpy code reviewer, you can use an AI coding companion (who's also a little less grumpy) customized to your unique code base, company's coding styles, best practices, patterns, and custom libraries and APIs. In this article, I will show how your company's Amazon Q Developer customizations will help you create more consistent code so you can keep your code DRY (the Don't Repeat Yourself principle of software development), improve on-boarding and knowledge transfer, and improve collaboration among your team.

Customization prerequisites

You'll need to have an Amazon Q Developer Pro subscription and your administrator will need to have already configured your access to the customizations. You can read more about the setup here (or just pass it over to your admin to handle).

In this article, I'm using a customization created based on the spring-petclinic projects and libraries. By creating the customization with your own unique coding style, libraries, and APIs, even different languages, Amazon Q will have more sample data to learn from and will be more equipped to match your intent to what it knows so it can provide better suggestions as you encounter various coding problems.

Let's check out a couple examples of how customizations work right in your IDE!

Creating a new entity using chat

I've been tasked with implementing a new entity, Order. Doing this without an AI coding companion means I'll need to look for existing patterns, copy/paste, find APIs we need, or code it up from scratch. This has the potential to create more code that is inconsistent with the rest of the code base. Instead, I'll use Amazon Q Developer to generate a code suggestion. I ask:

Create an implementation for a new entity called Order, in Java. Make sure to create the entity class and the repository implementation using JPA.

The response I get back is pretty generic:

import jakarta.persistence.*;
import java.time.LocalDate;

@Entity
@Table(name = "orders")
public class Order {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private LocalDate orderDate;

    @Column(nullable = false)
    private String status;

    // Constructors, getters, and setters

    // Additional fields and relationships as needed
}

I know that my team has established patterns for this code base that I should be following. This suggestion doesn't adhere to these patterns or use our libraries because Amazon Q doesn't have the full context. In this case, I know that the Order class should be extending the BaseEntity class that defines some base properties and logic that all of this project's entities should have. Imagine you're a developer new to this project. You may not have the same context I have.

This is where a Amazon Q Developer customizations can come in to help us. If we have a customization created and the chat customization feature (now in Preview) is enabled, we can ask Amazon Q again and get more customized information. I've written before about asking Amazon Q chat for code examples and we'll do the same here after selecting a customization to use.

When getting started with our work, we can select our code base's customization. First, select Amazon Q in the lower menu.

Then in the popup menu, select "Select Customization".

And then select your customization to use.

Now when I ask Amazon Q the same question, I get the following suggestion, which is using our established pattern of extending BaseEntity.

@Entity
@Table (name = "orders")
public class Order extends BaseEntity {

    @Column (name = "order_date")
    private LocalDate orderDate;

    @Column (name = "total_amount")
    private Double totalAmount;

    // Constructors, getters, and setters

    public Order() {
        // Default constructor
    }

    public Order(LocalDate orderDate, Double totalAmount) {
        this.orderDate = orderDate;
        this.totalAmount = totalAmount;
    }
    // Getters and setters

}

This is where Amazon Q Developer takes the selected customization and uses it to match my intentions to what it has learned so that it can generate a customized suggestion for me.

Creating a new entity using inline code suggestions

In the example below, we could also create the shell of our class file and use a comment to get an inline code suggestion from Amazon Q Developer to create this Order entity.

package com.anycompany.order;

// class representing an order entity using JPA

After triggering Amazon Q, the following code might be suggested if we're not using a customization:

package com.anycompany.order;

// class representing an order entity using JPA
import javax.persistence.GenerationType;
import java.util.Date;

@Entity
@Table(name = "orders")
public class Order {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "order_date")
    private Date orderDate;

    // constructors, getters and setters
}

If we select a customization and then trigger Amazon Q inline again, we would get a customized suggestion like the one we got using chat, including the use of the BaseEntity superclass.

As with other interactions with Amazon Q, if the suggestions aren't what you're looking for, you can either accept one and tailor it to your needs (you probably will have to do this at some point) or you can provide more context to nudge it in the right direction. You could import libraries you know you want to use, add some additional comments, and ensure you're using descriptive function and variable names. doStuff isn't going to cut it here!

Now that we've checked out how this works in action, let's review some of the benefits we get.

Keep your code DRY

Using a customization could be really powerful in the context of a large, quickly moving code base with many developers working in it. In the first example, it helps us keep our code DRY so that if the underlying implementation ever changes, the calling code doesn't also need to be changed.

When keeping our code DRY, we write less code. Our code becomes more readable (assuming the code we're calling uses descriptive names) and is easier to maintain and test.

It also means less can go wrong.

Improve on-boarding and knowledge transfer

Imagine if I'm new to this code base and don't yet know about all the existing libraries and APIs. I can ask Amazon Q to explain code snippets from a code base I'm just discovering or ask it to provide example code. I can describe my intent in a comment or function signature and Amazon Q will suggest code based on examples it learned from my company's private code base.

I've been using Amazon Q Developer's chat feature quite a bit to learn more about how a piece of code works, ask questions about my options for design and architecture or how to implement something, but now I can get suggestions based on my selected customization.

Improve collaboration

I mentioned earlier that grumpy code reviewer (we've all experienced one, right?!). Writing consistent code like we've covered here can also improve collaboration during code reviews and pair programming. Not only does my code reviewer or pair not have to remind me to use our already written, maintained, and tested library, but I have easy access to coding styles, standards, and best practices. Code suggestions while using a customization will already incorporate these and it's less likely that we'll argue over two spaces or four or whether or not we need to implement getOrderTotal three different ways.

Wrapping up

If you're working in a large code base, you might benefit from using a customized AI coding companion, like Amazon Q Developer. Today, I showed how using a customization based on your company's patterns, best practices, style guide, libraries, and APIs can help with readability and maintenance, on-boarding and knowledge transfer, and collaboration.

The Amazon Q Developer customizations feature for inline code suggestions just left Preview and the chat customization feature was released in Preview, both on July 10th. You can create your own customization (or ask your admin to set it up) by following these steps. Both features are continuously being improved based on your feedback, so if something isn't working as you expect, you find a bug, or even have suggestions to improve how it works in your development flow, let me know in the comments!

If you haven't yet tried out Amazon Q Developer in your development workflow, check out how to get started in VSCode or JetBrains IDEs.

Simplify your unit testing with generative AI

Jenna Pederson — Wed, 03 Jul 2024 14:30:00 +0000

When I write code, I write tests. But I especially hate the process of getting my test framework setup in my project and writing those first few tests that will eventually guide the way for a more full-fledged test suite.

Because of this, I have been experimenting with generative AI tools, like Amazon Q Developer, to support my testing efforts and to write and fix tests more quickly. I want to share with you today how I'm getting my test framework setup, creating those first few tests, and the back and forth prompts I'm using to be more productive.

In the examples below, I have a small React app using Typescript, deployed with AWS Amplify Gen 2. I like to get my test suite set up as I'm kicking off a project, so now is the time. Once my test suite is set up, I'll show you how to write a couple of tests and get a passing test suite.

Let's get started!

Setting up a test suite

It's been a bit since I've worked with React and so I'm looking to learn more about which testing framework is common practice to use. I've used Jest in the past, so I expect that will show up in my research.

I start by asking Amazon Q: What are some options for test frameworks for testing this React app? Test framework needs to support Typescript, be able to use the React Testing Library for component testing, and support mocking.

I get four options here, with Jest being one of them. Vitest looks interesting and this project is using Vite, so I ask for more info: Why would I choose Jest over Vitest?

I decide to go with Vitest and next I ask Amazon Q how to get my test suite set up: What are the steps I need to take to set up this project to use Vitest? Include React Testing Library, support for typescript.

I use the steps from the Amazon Q response as my guide to setting up the test suite. Before going through each step, I review them to make sure it's what I need, to make sure it's accurate enough to proceed. There were a couple of spots that gave me trouble and I'll point them out below.

Step 1: Install dependencies

I run the proposed command at the command line to install the Vitest, React Testing Library, and related dependencies:

npm install -D vitest @testing-library/react @testing-library/jest-dom @testing-library/user-event jsdom

Step 2: Configure Vitest

I create a vitest.config.ts file in the root of my project and paste in the proposed code:

/// <reference types="vitest" />
/// <reference types="vite/client" />

import react from '@vitejs/plugin-react';
import { defineConfig } from 'vitest/config';

export default defineConfig({
  plugins: [react()],
  test: {
    globals: true,
    environment: 'jsdom',
    setupFiles: ['./src/setupTests.ts'],
  },
});

3. Create a setup file

I create the setupTests.ts file in the src directory as referenced in the previous step and add the proposed code:

// src/setupTests.ts
import '@testing-library/jest-dom/extend-expect';

⚠️ Warning: For anyone scanning through this article for the code, the line above is actually incorrect and we fix it in the next section!

4. Update package.json

Finally, I update the package.json file to add the following to the scripts block:

{
  "scripts": {
    "test": "vitest"
  }
}

This will allow me to run npm test at the command line to run the tests and watch for changes. Everything so far has been smooth. Now it's time to write my first test.

Writing some tests

So far, the bulk of my work is in the RecipeList component that either lists a user's recipes or shows a "New recipe" button if they don't have any recipes yet. I know that I want the following five test cases:

display "Your Recipes" header text
display a button to create a new recipe
render a list of recipes when user has recipes
render a button to view each recipe when user has recipes
render a button to create a new recipe when user has no recipes

I have two approaches to create tests with Amazon Q. I can start by asking Q to suggest an example test: Give me an example vitest test for RecipeList. One test will test that RecipeList displays "Your Recipes" text. The second test will test that a button to create a "New Recipe" is displayed. Mock the useRecipeData hook to return a list of recipes from the default function.

Starting with this example, I clean this up. In the useRecipeData mock, I fix two issues:

remove the imports for React (unnecessary) and vitest (I'm using a global setup, so already imported; see step 2 in the previous section)
change the module path to ../hooks/useRecipeData
swap recipes for default because the hook I'm mocking uses a default export rather than a named export. In both tests, I add a <BrowserRouter> wrapper around the <RecipeList> component.

The test now looks like this:

// RecipeList.test.tsx
import { render, screen } from '@testing-library/react';
import { describe, it, vi } from 'vitest';
import RecipeList from './RecipeList';
import { BrowserRouter } from 'react-router-dom';

vi.mock('../hooks/useRecipeData', () => ({
  default: () => ({
    recipes: [],
  }),
}));

describe('RecipeList', () => {
  it('should display "Your Recipes" text', () => {
    render(
      <BrowserRouter>
        <RecipeList />
      </BrowserRouter>
    );
    const yourRecipesText = screen.getByText('Your Recipes');
    expect(yourRecipesText).toBeInTheDocument();
  });

  it('should display a button to create a new recipe', () => {
    render(
      <BrowserRouter>
        <RecipeList />
      </BrowserRouter>
    );
    const newRecipeButton = screen.getByRole('button', { name: /New Recipe/i });
    expect(newRecipeButton).toBeInTheDocument();
  });
});

Now, it's time to check if the tests pass or fail!

Run the test suite to get green

In the terminal, I run npm test to run the tests and watch for changes. I immediately run into an error. I'm not sure what this means, so I ask Amazon Q for help:

What does this error message mean:Error: Missing "./extend-expect" specifier in "@testing-library/jest-dom" packagewhen runningnpm test?

Based on the response, I need to update our setupTests.ts file from:

// setupTests.ts
import '@testing-library/jest-dom/extend-expect';

To:

// setupTests.ts
import '@testing-library/jest-dom';

So that it uses the default export, rather than the removed extend-expect named export.

After saving the file, the tests are automatically rerun and this issue is resolved. However, the tests are not yet green and passing. The test should display "Your Recipes" text fails because Your Recipes should only be displayed when the user has no recipes and we set this up with an empty list.

Let's fix that by adding some mock recipes. Because vi.mock is hoisted to the top of the file, I also need to make mockRecipes hoisted, by using vi.hoisted. I then move these to a beforeEach block:

beforeEach(() => {
  const mocks = vi.hoisted(() => {
    return {
      mockRecipes: [
        { id: '1', title: 'Recipe 1', instructions: 'Instructions 1' },
        { id: '2', title: 'Recipe 2', instructions: 'Instructions 2' },
      ]
    }
  })

  vi.mock('../hooks/useRecipeData', () => ({
    default: vi.fn().mockReturnValue({
      recipes: mocks.mockRecipes,
    }),
  }));
});

After saving the file, all of the tests are passing! My (very small) test suite is green! Next, I can write a few more tests to extend the test suite.

Bonus: Add more tests

Once I have the core of a test stubbed out, I can start typing out code and let Amazon Q's inline code prompting make suggestions for me. Another test I want to add is render a list of recipes when user has recipes. To use Amazon Q's inline code suggestions, I start typing out the test with the description of what I want. In the screenshot below, I start typing this line:

it('should render a list of recipes when user has recipes', async () => {

Amazon Q will provide a suggestion automatically (see the light grey suggestion in the screenshot, between lines 47-48) or I can use the shortcuts Option+C (Mac) or Alt+C (Windows). I like the suggestion, so I hit Tab to accept it.

My final test looks like this:

// RecipeList.test.tsx
import { render, screen, cleanup } from '@testing-library/react';
import RecipeList from './RecipeList';
import { BrowserRouter } from 'react-router-dom';

const mocks = vi.hoisted(() => {
  return {
    mockRecipes: [
      { id: '1', title: 'Recipe 1', instructions: 'Instructions 1' },
      { id: '2', title: 'Recipe 2', instructions: 'Instructions 2' },
    ]
  }
})

describe('RecipeList', () => {
  beforeEach(() => {
    cleanup();

    vi.mock('../hooks/useRecipeData', () => {
      return {
        default: vi.fn().mockReturnValue( {
          recipes: mocks.mockRecipes
        }),
      }
    })
  });

  it('should display "Your Recipes" text', () => {
    render(
      <BrowserRouter>
        <RecipeList />
      </BrowserRouter>
    );
    const yourRecipesText = screen.getByText('Your Recipes');
    expect(yourRecipesText).toBeInTheDocument();
  });

  it('should display a button to create a new recipe', () => {
    render(
      <BrowserRouter>
        <RecipeList />
      </BrowserRouter>
    );
    const newRecipeButton = screen.getByRole('button', { name: /New Recipe/i });
    expect(newRecipeButton).toBeInTheDocument();
  });

  it('should render a list of recipes when user has recipes', async () => {
    render(
      <BrowserRouter>
        <RecipeList />
      </BrowserRouter>
    );

    expect(await screen.findByText('Recipe 1')).toBeInTheDocument();
    expect(screen.getByText('Recipe 2')).toBeInTheDocument();
  });

  it('should render a button to view each recipe when user has recipes', async () => {
    render(
      <BrowserRouter>
        <RecipeList />
      </BrowserRouter>
    );

    const viewButtons = await screen.findAllByText('View');
    expect(viewButtons).toHaveLength(2);
  })

  it('should render a button to create a new recipe when user has no recipes', async () => {
    vi.doMock('../hooks/useRecipeData', () => {
      return {
        default: vi.fn().mockReturnValue( {
          recipes: []
        }),
      }
    })

    render(
      <BrowserRouter>
        <RecipeList />
      </BrowserRouter>
    );

    expect(await screen.findByText('New Recipe')).toBeInTheDocument();
  });
});

Wrapping up

That's it! The test suite is green. In this article, I showed you how to setup a Vitest test suite to be used with Typescript and React Testing Library. We chose Vitest over Jest because the project uses Vite but we still interact with it a lot like Jest. We wrote some tests and then ran them from the command line using Vitest's test runner command that watches for changes to tests or code under test. We used Amazon Q Developer to support our work throughout, asking it questions, for example code, for help with errors, and used inline code suggestions. Ready to try Amazon Q Developer in your testing flow? Check out how to get started in VSCode or JetBrains IDEs.

Have you been using an AI assistant to help you with testing? Drop a comment 💬 below to share what tool you're using and how it helps you.

A practical approach to using generative AI in the SDLC

Jenna Pederson — Wed, 19 Jun 2024 13:02:00 +0000

Have you ever taken requirements from a stakeholder, implemented them, only to have them come back to you and say "That's not what I asked for! I meant this..." It happens all the time. Sometimes we heard them wrong, sometimes we made incorrect assumptions, or maybe even the needs of the end-user changed.

You may have already seen how an AI assistant like Amazon Q Developer can help you write code and make your development more productive, and today I'd like to show you how I'm using an AI assistant to support the rest of my software development process, from idea to launch and beyond.

In the examples below, my stakeholders want to build a way for their customers to share and discover recipes and I'm using Amazon Q Developer to help me figure out what to build and how to build it. We'll step through each phase of the software development life cycle (SDLC) and this will be relevant whether you're using a traditional waterfall process or agile methodologies.

Let's get started!

Analysis, requirements, and planning

During the analysis, requirements, and planning phases of the SDLC, I'm doing a lot of information gathering, asking questions, and researching the domain. I can use Amazon Q Developer to help me with this. Using the stakeholder business idea to create a recipe sharing and discovery app, I can ask the following questions:

I'm creating a platform for users to share and discover recipes, including ingredients, steps, and images. What sort of functional and non-functional requirements should I be thinking about?

Some other questions I might ask:

What questions should I be asking my customer?

What are some challenges in the recipe app domain that I need to account for?

What are some questions I should be asking you about the functional and non-functional requirements of this recipe app?

I can use these tools to better prepare me for planning meetings, ask the right questions, help think about functional and non-functional requirements, all as input into the design and architecture phase.

Design and architecture

During the design phase, I start thinking more concretely about what the architecture will look like.

I need to find accurate, up-to-date information and guidance to help me understand potential solutions, which AWS services I should use, and how to use them. Instead of spending hours reading through AWS documentation, reading through blog posts, searching on Google, before even getting started, I can explore different approaches and provide initial ideas for the design and architecture phase, evaluate pros and cons, and even get a recommendation from an AI assistant like Amazon Q Developer.

Whether you enter this phase as someone new to the tech or the domain or you're armed with knowledge and years of experience, you still have to sift through it the information, evaluate your options, and make decisions. These tools help me gain clarity by narrowing down options based on the inputs I already have (functional and non functional requirements), the trade-offs I need to think about, and help make design and architectural decisions.

In the recipe sharing app my stakeholders want me to build, I can ask questions like:

I would like to use AWS to deploy this web app. My team is made up of mostly Python engineers. We'll use Flask to build the app. What options do I have to deploy this app on AWS that include using infrastructure as code?

Some other questions I might ask:

What are the different tradeoffs I need to think about when choosing to use Amazon ECS for this app?

Assuming we use ECS, what are the different tradeoffs I need to think about when choosing to use AWS CDK or CloudFormation for this project?

At this point, I have enough information to make a decision on how to proceed. I've decided to use Amazon ECS with Fargate to deploy this Flask app. Now I can start on the development of the app.

Development

An AI assistant also helps me with many of my development tasks. Once I know what I need to build and how to communicate that to my tools, I can start asking questions about the implementation details.

I can use it to learn how to work with libraries and APIs, explain a block of code, refactor, ask for steps on how to implement a new feature with code examples, get code completions based on existing code and comments.

Using the same example, I ask:
What are the steps to bootstrap a simple Flask app that has one route "/recipes" that outputs "My Recipes" text? I need to set up a python virtual environment and requirements.txt as part of this.

I can generate code inline, right in my IDE, based on existing code and comments:

I can also troubleshoot and debug issues, fix faulty code, or configuration. I often paste in my stack traces and ask for help:

When I run "python app.py" my Flask app does not start. There is no output when the command completes. Where should I investigate?

I'm getting this stack trace when I hit the recipes route /recipes. The app starts ok and the root route / works ok. What are some reasons I might get this error and how can I resolve it?

Hopefully, this means less forgotten print('GOT HERE') lines! Using an AI assistant to debug an issue after I've found is great, but I can also use one to prevent bad code by helping me write tests.

Testing

One of my favorite ways to use an AI assistant is to help with my tests. Often there's a recipe (pun intended!) to setting up the test suite and getting the first piece of code under test. Often this is boilerplate code, so I can use Amazon Q Developer to set up my test suite, to stub out a new test class, generate test cases based on existing code or a set of requirements via prompt, and even generate synthetic data for testing purposes.

In the recipe sharing app, I can ask questions like:

I want to create a unit test for the "/recipes" route using the unittest framework. What are the steps and example code to do that?

I might also ask questions about how to set up my test suite and run it, especially if this is a new-to-me code base:

I have python tests cases created in this project. Which dependencies need to be installed so that I can run these tests and how do I run the test suite?

Or to use the mocking library:

I need to mock the API call to Amazon Bedrock in the /generate-recipe route. How can I use the unittest.mock library to do this? Please provide an example.

Deployment

During the deployment phase, I can use an AI assistant to help write my infrastructure code, create deployment scripts, learn about command line deployment tools, and create images and diagrams for my docs.

For my app, I can ask:

What are the steps to deploy this Flask app as a container to ECS using Fargate?

And when I'm ready to set up my CI/CD pipeline, I might start by asking for high-level steps and then drill down into each step with more specific questions:
What are the steps to set up this project's CI/CD pipeline using GitHub Actions? When a commit is made to the code repository, this action will automatically coordinate building, testing, and deploying the application to ECS for every push to the repository.

Once I've deployed the app to production and end-users are using it, I'm not done. I still need to maintain it over time.

Maintenance

During the maintenance phase, I can use an AI assistant to learn about legacy codebases, an application's architecture, or a new programming language.

I can use the Amazon Q Developer's Explain feature to get more info about a selected block of code:

Or even get ideas on how to optimize my AWS bill right from the AWS Console:

How can I optimize my bill this month?

I can transform, migrate, and upgrade a codebase or an application and I can refactor or optimize code, or even evaluate security vulnerabilities using an AI assistant.

Wrapping up

As you use a tool like this, it's important to understand how your AI assistant is trained -- on what data, for what tasks -- and then use it appropriately, using your own judgement. You may not use Amazon Q Developer in your IDE to ask about stakeholder questions, but in my situation, it worked for me. You likely wouldn't ask for unit test code examples in the AWS Console, but you would in your IDE, because that's where you are doing that work.

These are only some of the many ways you could use an AI assistant like Amazon Q Developer to help you throughout the SDLC. Whether you're using a variation of waterfall or an agile process, you can incorporate an AI assistant like Amazon Q Developer into your process. Read more about AI assistants on the Community.aws space or get started in VSCode, JetBrains IDEs, or even the command line.

How are you using AI assistants to help you with your development process? Drop a comment below to share and help others.

I'm a lazy developer. Here's how Amazon Q is enabling me

Jenna Pederson — Tue, 18 Jun 2024 19:27:06 +0000

I'm always on the hunt for ways to improve my productivity as a developer. I've spent the better part of the last two weeks diving head first into using Amazon Q Developer, experimenting with how it might work in my development flow, learning the ins and outs, and chatting with coworkers about how they are using it. Today, I want to share what I've learned so far, how I'm tweaking my productivity and staying in the flow.

Reduce my context switching

When I'm writing code, I want to get in the flow and stay in the flow. Context switching -- flipping between apps, back and forth between browser tabs, a google search here, and StackOverflow search there, the ding of an email, a bleep of a Slack notification (oops, I'm late for a meeting) -- all of this comes with a cost.

I'm finding that Amazon Q Developer keeps me in my IDE. Instead of hopping over to a browser to do a google search or to read through documentation for my programming language, the framework I'm using, or the AWS docs, I can use this tool to do this digging for me.

I can ask how to get started with a new project. Here, I started with the prompt What are the steps to creating a python Flask app? Amazon Q Developer outlines the steps I need to take to get started, providing me with both code snippets and explanations.

I can never remember the steps to create a python virtual environment so I ask it questions like How do I initialize a python virtual environment?

And if I want to go deeper, I'm even presented with external references backing up the responses.

All of this allows me to stay in my IDE, reducing my context switching, and stay in the flow. Check out how my colleague stays in the flow with Amazon Q.

Support for my lazy developer mentality

According to the creator of the Perl programming language, Larry Wall, laziness is one of the virtues of a good programmer. For a programmer to be effective and efficient, they must also be lazy. But not in the traditional, lounge on your couch and watch TV all day and be lazy sense. Instead, a lazy developer is interested in saving time, automating tasks, especially the boring, time consuming, or brittle ones, documenting work for others.

That's me. I'm a lazy developer.

I don't remember all the properties for an HTML text area. So I ask Amazon Q to do the research for me and propose examples for boilerplate code like HTML elements and unit tests.

I ask it to explain a block of code by selecting it and then using the "Send to Amazon Q" menu option:

And the response I get back:

And then I wanted more detail on the json.loads line:

In a previous life, I often worked as a team of one, inheriting someone else's codebase. I would come into a new codebase with no other teammates to help me figure out what was going on. This is where Amazon Q can help you get up to speed quickly, summarizing blocks of code, functions, or even whole files.

Help me debug

One challenging task for developers is debugging hairy bugs. It's hard because you end up having to shove a bunch of info into your short term memory in order to trace through layers and layers of code, some of which you may not even be familiar with. Then... BAM! Slack notification, time for a meeting! You drop everything for an hour and come back to debugging and have to start that trace over again. Or you're chasing through multiple API docs trying to figure out whether you've correctly understood how to make a call and which parameters to send and how to handle the response.

That's exactly what just happened to me as I was trying to make a call to Amazon Bedrock's invoke_model API.

I messed it up! So I asked Amazon Q for an assist:

I had also messed up the format of the response body, so I used Amazon Q to help me debug through that as well:

It's important to recognize that LLMs are backing Amazon Q, which means it will experience hallucinations just like any other model. I did have some extra debugging because of this as the example code proposed using ModelId and Body when calling invoke_model when they should have been lower-case modelId and body.

Want to see more complex debugging scenarios with Amazon Q? Check out my colleagues' experiences solving a data serialization problem and finding and fixing a concurrency bug.

Help me write tests

I am an avid tester, so when I'm writing code, I'm often pairing it up with unit tests at a minimum. I have not had much experience using mocks in Python tests, so I asked Q How would you write a test for the send_prompt_to_bedrock function using mocks? and got this response:

It gets me a lot closer than had I started with a google search, dug through some documentation, and started by writing the boilerplate code myself. This response is an example customized to what I am doing, so I don't have to try to translate what one blog post author was trying to do in their situation to what I'm trying to do in my situation. I didn't spend much time getting this test to pass, most of my time was making sure the request/response objects were prepared correctly.

Read more about how my colleagues are using Amazon Q for writing tests earlier and for test driven development.

Wrapping up

Hopefully the only thing you took away from this article wasn't that I'm a lazy developer! Here, I covered four different ways I'm tweaking my productivity as a developer so I can stay in the flow:

I'm reducing my context switching by staying in my IDE
I'm getting support for my lazy developer mentality by generating boilerplate code, summarizing what code is doing, and getting help with refactoring
I'm delegating my debugging work
I'm getting help with writing my unit tests

Are you ready to get started with Amazon Q Developer in your IDE? Check out how to set it up for VS Code or JetBrains IDEs or even the command line. Amazon Q Developer just left Preview on April 30th and is continuously being improved based on your feedback. If something isn't working as you expect, you find a bug, or even have suggestions to improve how it works in your development flow, let me know in the comments!