There's been an explosion of tools claiming to make your job easier and touting GenAI, and I'm sure many of them can be very helpful. However, it can be hard to get support at many companies to integrate large new suites of tools into a process. It's often easier to add tools to your tasks. That's where the idea for this post came from.

Last year, I told my boss and co-workers about AWS's PartyRock tool. We'd been experimenting with tools like ChatGPT and HuggingChat and found some use cases, but we'd have to paste the prompt every time. It didn't make things easy to reuse and share. We had a lot of success with PartyRock, and now we're starting to use what was built with PartyRock to automate processes.

What is PartyRock?

PartyRock is a GenerativeAI-based tool that builds AI-powered applications using GenAI. The quickest way to get started is to write a prompt explaining what you want the application to do, and then PartyRock creates that application. There are some significant limitations to that. It won't turn your start-up idea into a working SaaS offering but can help with specific and limited tasks.

Here are some application examples from PartyRock's site:

  • Create a meeting summary and list of action items when given meeting notes.
  • Compare a job description and your resume and highlight gaps in your resume.
  • Get grammar and writing feedback using PartyRock like an editor.

A prompt for PartyRock will tend to be complex, but they have many examples to help get you started. Once you've generated your application, you can also fine-tune it by adjusting the prompts and other behaviors.

PartyRock is currently free to use, but if you're going to use it for your job, you should probably disable sharing data with AWS. You should also review PartyRock's privacy policy, terms of service, and other legal stuff, along with your company's AI-use policies, to make sure what you're doing isn't going to cause problems, especially if you put anything sensitive into PartyRock.


Go to "Backstage" in PartyRock's menu to find the option to disable sharing data with AWS.

What we did with PartyRock

We've tried out several different ideas with PartyRock, and I'm not going to go through all of them. Some didn't work out well, and some border on proprietary. One example I don't think anyone will mind my sharing is a tool to provide an initial review of RFPs.

RFPs, or requests for proposals, are a big part of public-sector work. When working with governments and public institutions, like public schools, not public companies, there are generally rules about ensuring adequate competition between vendors that wish to provide services to the organization. That generally means documents are created that highlight the work that needs to be done, the expectations and requirements for the work, how the grading of a proposal works, and all kinds of other information. These documents are called RFPs and are what vendors use to create a proposal to try and win the work. Sometimes, these RFPs are a handful of pages long. Sometimes, they are hundreds of pages long. Reviewing these documents to see if they match your services can be a long and tedious process, and the format and quality of RFP documents are inconsistent. You can't just scroll to the page that says "services requested." Sometimes, that information is called out clearly. Sometimes, special codes indicate categories of services requested, and sometimes, you have to guess what the author was trying to request.

Since these documents are generally required to be publicly accessible by law, there isn't too much concern about putting them into a GenAI tool, especially since we don't get RFPs for classified projects in the part of the company I work in. Only RFPs that are already accessible online.

We used PartyRock to inspect these documents and determine the services being requested, how they match up against the services we offer, estimated budgets and timelines, and all kinds of other information that can quickly help us determine whether we want to read the entire RFP document. It's a huge timesaver! With PartyRock, we drop the PDF document onto the page, and PartyRock extracts and inspects the text. If we get a PDF from scanned documents, it doesn't work, but those RFPs aren't very common. Typically, everything is written on a computer, so extracting text from the PDF isn't hard.

Next Step - Bedrock APIs

Having refined our prompts in PartyRock, we're now experimenting with integrating Amazon Bedrock into some of our tools and processes. We're a bunch of software engineers and use some open-source tools, so extending things with new functionality isn't a big step.

Bedrock is AWS's serverless way to use different foundational models, without spinning up a bunch of infrastructure. We could do this all with SageMaker and other tools, or we can build on top of Bedrock. Which is what PartyRock does.

We were a little concerned that working with documents and Bedrock was going to mean a bunch of effort by using Texttract. I was glad we were proven wrong. I was able to build a quick proof of concept using the Bedrock API in 10 - 15 minutes.

Using a very basic prompt and a small sample document I wrote myself, I was able to call Bedrock's API and get a response from Amazon's Nova Lite model.

import { readFileSync } from 'node:fs';
import { join } from 'node:path';
import {
  BedrockRuntimeClient,
  ConverseCommand,
} from '@aws-sdk/client-bedrock-runtime';

const sampleDocument = readFileSync(join(__dirname, '..', 'sample.pdf'));

const client = new BedrockRuntimeClient({
  region: 'us-east-1',
});

client
  .send(
    new ConverseCommand({
      modelId: 'amazon.nova-lite-v1:0',
      messages: [
        {
          role: 'user',
          content: [
            {
              document: {
                name: 'rfp',
                format: 'pdf',
                source: {
                  bytes: sampleDocument,
                },
              },
            },
            {
              text: 'Review the RFP, and provide a summary of the services being requested',
            },
          ],
        },
      ],
    }),
  )
  .then((resp) => {
    console.log(JSON.stringify(resp, null, 2));
  });

Once I knew I could get the kind of output I needed, I started working on an API to allow us to easily call Bedrock on the format we needed.

API Gateway & Bedrock

I initially looked at directly integrating Amazon API Gateway with the Bedrock API through an AWS service integration. I'm a big supporter of avoiding unnecessary Lambda functions and having API Gateway directly call services whenever possible. AWS Hero Yan Cui recently posted on LinkedIn and uploaded a YouTube video discussing the same thing. Unfortunately, API Gateway doesn't currently support Bedrock. At least, not easily. Hopefully that'll be added soon.

💡 If you haven't used AWS service integrations with API Gateway, you should take a look at this tutorial from AWS.

So I created a Lambda function that handles the API call to Bedrock and had API Gateway invoke the Lambda function. Altogether, it took a couple of hours to build an API that is good enough to start adding GenAI into our processes.

The Road Ahead

We still need to use this API, but being able to use Bedrock so easily seems like a game changer. PartyRock was great when just a few of us were trying something out, but now that we have a use case worth being scaled out, it's time to use Bedrock directly and remove as much of the manual process as possible.

Author Of article : Jason Butz Read full article