Add a new module for MCP specific traits with Prompts trait

[yasmewad]

This PR introduces a new @prompts trait that enables Smithy service authors to provide contextual guidance for Large Language Models (LLMs) when interacting with their services. The trait can be applied to services, resources, and operations to define prompt templates, parameter descriptions, and usage conditions.

The logic for using the data from the traits to serve prompts as part of the MCP server will be a separate PR.

Key features:
• Prompt Templates: Define template text with placeholders for parameters and multi-operation workflows
• Parameter Guidance: Optional argument descriptions to help LLMs understand parameter usage
• Conditional Usage: Specify when certain operations should be preferred over others
• Flexible Application: Can be applied at service, resource, or operation level

Added an example that builds.

Example Usage

$version: "2"
                                                                                                                                                                                                                                                                                                                           
namespace com.example
                                                                                                                                                                                                                                                                                                                           
use amazon.smithy.llm#prompts
                                                                                                                                                                                                                                                                                                                           
@prompts({                                                                                                                                                                                                                                                                                                                 
    "search_users": {                                                                                                                                                                                                                                                                                                      
        description: "Search for users in the system by various criteria"                                                                                                                                                                                                                                                  
        template: "Search for users where {searchCriteria}. Use pagination with limit={limit} if many results expected."                                                                                                                                                                                                   
        arguments: SearchUsersInput                                                                                                                                                                                                                                                                                        
        preferWhen: "User wants to find specific users or browse user lists"                                                                                                                                                                                                                                               
    }                                                                                                                                                                                                                                                                                                                      
    "get_user_details": {                                                                                                                                                                                                                                                                                                  
        description: "Retrieve detailed information about a specific user"                                                                                                                                                                                                                                                 
        template: "Get detailed information for user with ID {userId}. This provides complete user profile data."                                                                                                                                                                                                          
        arguments: GetUserInput                                                                                                                                                                                                                                                                                            
        preferWhen: "User asks for specific details about a known user"                                                                                                                                                                                                                                                    
    }                                                                                                                                                                                                                                                                                                                      
})                                                                                                                                                                                                                                                                                                                         
service UserService {                                                                                                                                                                                                                                                                                                      
    operations: [SearchUsers, GetUser]                                                                                                                                                                                                                                                                                     
}                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                           
@prompts({                                                                                                                                                                                                                                                                                                                 
    "create_with_validation": {                                                                                                                                                                                                                                                                                            
        description: "Create a new user with input validation"                                                                                                                                                                                                                                                             
        template: "Create user with name='{name}' and email='{email}'. Validate email format before submission."                                                                                                                                                                                                           
        arguments: CreateUserInput                                                                                                                                                                                                                                                                                         
    }                                                                                                                                                                                                                                                                                                                      
})                                                                                                                                                                                                                                                                                                                         
operation CreateUser {                                                                                                                                                                                                                                                                                                     
    input: CreateUserInput                                                                                                                                                                                                                                                                                                 
    output: CreateUserOutput                                                                                                                                                                                                                                                                                               
}                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                           
structure SearchUsersInput {                                                                                                                                                                                                                                                                                               
    searchCriteria: String                                                                                                                                                                                                                                                                                                 
    limit: Integer                                                                                                                                                                                                                                                                                                         
}                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                           
structure GetUserInput {                                                                                                                                                                                                                                                                                                   
    userId: String                                                                                                                                                                                                                                                                                                         
}                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                           
structure CreateUserInput {                                                                                                                                                                                                                                                                                                
    name: String                                                                                                                                                                                                                                                                                                           
    email: String                                                                                                                                                                                                                                                                                                          
}                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                           

By submitting this pull request, I confirm that you can use, modify, copy, and redistribute this contribution, under the terms of your choice.

[adwsingh]

IDK, these feel very MCP specific and I wouldn't like to name something tied to a particular model architecture.

Either we keep the namespace as software.amazon.smithy.mcp or software.amazon.smtihy.ai

[yasmewad]

I discussed with @mtdowling and we are going to be placing these in smithy.llm following the patterns for smithy.api, smithy.rules , etc.

[yasmewad]

Right now that change is blocked on a PR to update logic on trait-codegen plugin restrictions being flexible.
Also this namespace is pretty changeable. The software.amazon.smithy.llm will be the package name used for the Java classes generated off it.

[rhernandez35]

llm is technically incorrect. These traits are for use with generative AI, but llm refers to a specific type of model architecture.

[yasmewad]

Hmm. So how about smithy.ai ?

[yasmewad]

And for the package name for java class as software.amazon.smtihy.ai ?

[rhernandez35]

That would work

[yasmewad]

@mtdowling and @kstich you good with the naming?

[rhernandez35]

Traits are A-OK

[kstich]

This should be @private.

[yasmewad]

Ack. Will update with the namespace update PR.

[kstich]

This should be @private.

[yasmewad]

Ack. Will update with the namespace update PR.

[kstich]

The seems MCP specific, @mcpPrompts?

[rhernandez35]

We want to avoid directly naming any protocols in case we support more in the future