Name:
interface
Value:
Amplify has re-imagined the way frontend developers build fullstack applications. Develop and deploy without the hassle.

Choose your framework/language

Page updated Nov 19, 2024

Generation

AI generation routes are a request-response API used to generate structured output from AI models. Examples of generation routes include:

  • generated structured data from unstructured input
  • summarization

Under the hood, a generation route is an AWS AppSync query that ensures the AI model responds with the response type defined for the route.

Generate Typed Objects

Schema Definition
const schema = a.schema({
generateRecipe: a.generation({
aiModel: a.ai.model('Claude 3 Haiku'),
systemPrompt: 'You are a helpful assistant that generates recipes.',
})
.arguments({ description: a.string() })
.returns(
a.customType({
name: a.string(),
ingredients: a.string().array(),
instructions: a.string(),
})
)
.authorization((allow) => allow.authenticated())
});
import { generateClient } from "aws-amplify/api";
import { createAIHooks } from "@aws-amplify/ui-react-ai";
import { Schema } from "../amplify/data/resource";
const client = generateClient<Schema>({ authMode: "userPool" });
const { useAIGeneration } = createAIHooks(client);
export default function Example() {
// data is React state and will be populated when the generation is returned
const [{ data, isLoading }, generateRecipe] =
useAIGeneration("generateRecipe");
const generateSummary = async () => {
generateRecipe({
description: 'I would like to bake a birthday cake for my friend. She has celiac disease and loves chocolate.',
});
};
}

Generate Scalar Types

Schema Definition
const schema = ({
summarize: a.generation({
aiModel: a.ai.model('Claude 3 Haiku'),
systemPrompt: 'Provide an accurate, clear, and concise summary of the input provided'
})
.arguments({ input: a.string() })
.returns(a.string())
.authorization((allow) => allow.guest()),
});
Data Client Request
const { data: summary, errors } = await client.generations
.summarize({ input })

Setting Inference Parameters

You can influence response generation by setting inference parameters for the AI model. This ability to control the randomness and diversity of responses is useful for generating responses that are tailored to your needs.

More information about inference parameters.

Inference Parameters
const schema = a.schema({
generateHaiku: a.generation({
aiModel: a.ai.model('Claude 3 Haiku'),
systemPrompt: 'You are a helpful assistant that generates haikus.',
inferenceConfiguration: {
maxTokens: 1000,
temperature: 0.5,
topP: 0.9,
}
}),
});

Limitations

1. Generation routes do not support referencing models

For example, the following schema defines a Recipe model, but this model cannot be used as the return type of a generation route.

Invalid Model Reference
const schema = a.schema({
Recipe: a.model({
name: a.string(),
ingredients: a.string().array(),
instructions: a.string(),
}),
generateRecipe: a.generation({
aiModel: a.ai.model('Claude 3 Haiku'),
systemPrompt: 'You are a helpful assistant that generates recipes.',
})
.arguments({ description: a.string() })
.returns(a.ref('Recipe')) // ❌ Invalid
.authorization((allow) => allow.authenticated()),
});

You can, however, reference custom types. Here's an example of a custom type that can be used as the return type of a generation route.

Valid Custom Type Reference
const schema = a.schema({
Recipe: a.customType({
name: a.string(),
ingredients: a.string().array(),
instructions: a.string(),
}),
generateRecipe: a.generation({
aiModel: a.ai.model('Claude 3 Haiku'),
systemPrompt: 'You are a helpful assistant that generates recipes.',
})
.arguments({ description: a.string() })
.returns(a.ref('Recipe')) // ✅ Valid
.authorization((allow) => allow.authenticated()),
});

2. Generation routes do not support some required types.

The following AppSync scalar types are not supported as required fields in response types:

  • AWSEmail
  • AWSDate
  • AWSTime
  • AWSDateTime
  • AWSTimestamp
  • AWSPhone
  • AWSURL
  • AWSIPAddress
Unsupported Required Type
const schema = a.schema({
generateUser: a.generation({
aiModel: a.ai.model('Claude 3 Haiku'),
systemPrompt: 'You are a helpful assistant that generates users.',
})
.arguments({ description: a.string() })
.returns(
a.customType({
name: a.string(),
email: a.email().required(), // ❌ Required field with unsupported type
dateOfBirth: a.date().required(), // ❌ Required field with unsupported type
})
)
.authorization((allow) => allow.authenticated()),
});