Ir al contenido
@aws/nx-plugin
Blog

Implementar la API del juego y el servidor MCP de inventario

Tarea 1: Implementar la API del juego

Sección titulada «Tarea 1: Implementar la API del juego»

Implementaremos las siguientes APIs en esta sección:

  1. saveGame - crear o actualizar un juego.
  2. queryGames - devolver una lista paginada de juegos guardados previamente.
  3. queryInventory - devolver una lista paginada de elementos en el inventario de un jugador.
  4. queryActions - devolver el historial de conversación para un juego dado.

Esquema de la API

Sección titulada «Esquema de la API»

Para definir nuestras entradas y salidas de la API, creemos nuestro esquema usando Zod dentro del archivo packages/game-api/src/schema/index.ts de la siguiente manera:

import { z } from 'zod';


export const QueryInputSchema = z.object({
  cursor: z.string().optional(),
  limit: z.number().optional().default(100),
});
export type IQueryInput = z.TypeOf<typeof QueryInputSchema>;


export const ActionSchema = z.object({
  role: z.enum(['user', 'assistant']),
  content: z.string(),
  messageId: z.number(),
});
export type IAction = z.TypeOf<typeof ActionSchema>;


export const GameSchema = z.object({
  playerName: z.string(),
  genre: z.enum(['zombie', 'superhero', 'medieval']),
  lastUpdated: z.iso.datetime(),
});
export type IGame = z.TypeOf<typeof GameSchema>;


export const ItemSchema = z.object({
  playerName: z.string(),
  itemName: z.string(),
  emoji: z.string().optional(),
  lastUpdated: z.iso.datetime(),
  quantity: z.number(),
});
export type IItem = z.TypeOf<typeof ItemSchema>;


export const createPaginatedQueryOutput = <ItemType extends z.ZodTypeAny>(
  itemSchema: ItemType,
) => {
  return z.object({
    items: z.array(itemSchema),
    cursor: z.string().nullable(),
  });
};

Elimina el archivo packages/game-api/src/schema/echo.ts ya que no lo usaremos en este proyecto.

Modelado de entidades

Sección titulada «Modelado de entidades»

Este es el diagrama ER para nuestra aplicación.

Diagram

El generador ts#dynamodb configuró ElectroDB, que usaremos para modelar nuestros datos. Persistiremos el historial de conversación en S3, así que agregamos una dependencia en el cliente de S3:

Terminal window
pnpm add @aws-sdk/client-s3@3.1111.0 --filter game-api

Reemplaza la entidad de ejemplo generada en packages/dungeon-db/src/entities/index.ts con nuestras entidades Game e Inventory, y elimina packages/dungeon-db/src/entities/example.ts:

import { Entity } from 'electrodb';
import { getDynamoDBClient, resolveTableName } from '../client.js';


export const createGameEntity = async () =>
  new Entity(
    {
      model: {
        entity: 'Game',
        version: '1',
        service: 'game',
      },
      attributes: {
        playerName: { type: 'string', required: true, readOnly: true },
        genre: { type: 'string', required: true, readOnly: true },
        lastUpdated: {
          type: 'string',
          required: true,
          default: () => new Date().toISOString(),
        },
      },
      indexes: {
        primary: {
          pk: { field: 'pk', composite: ['playerName'] },
          sk: { field: 'sk', composite: [] },
        },
      },
    },
    { client: getDynamoDBClient(), table: await resolveTableName() },
  );


export const createInventoryEntity = async () =>
  new Entity(
    {
      model: {
        entity: 'Inventory',
        version: '1',
        service: 'game',
      },
      attributes: {
        playerName: { type: 'string', required: true, readOnly: true },
        lastUpdated: {
          type: 'string',
          required: true,
          default: () => new Date().toISOString(),
        },
        itemName: {
          type: 'string',
          required: true,
        },
        emoji: {
          type: 'string',
          required: false,
        },
        quantity: {
          type: 'number',
          required: true,
        },
      },
      indexes: {
        primary: {
          pk: { field: 'pk', composite: ['playerName'] },
          sk: { field: 'sk', composite: ['itemName'] },
        },
      },
    },
    { client: getDynamoDBClient(), table: await resolveTableName() },
  );

ElectroDB nos permite no solo definir nuestros tipos, sino que también puede proporcionar valores predeterminados para ciertos valores como marcas de tiempo. Además, ElectroDB sigue el diseño de tabla única que es la mejor práctica al usar DynamoDB.

Definiendo nuestros procedimientos

Sección titulada «Definiendo nuestros procedimientos»

Para implementar los métodos de la API, realiza los siguientes cambios dentro de packages/game-api/src/procedures:

import { createGameEntity } from '@dungeon-adventure/dungeon-db';
import {
  GameSchema,
  IGame,
  QueryInputSchema,
  createPaginatedQueryOutput,
} from '../schema/index.js';
import { publicProcedure } from '../init.js';


export const queryGames = publicProcedure
  .input(QueryInputSchema)
  .output(createPaginatedQueryOutput(GameSchema))
  .query(async ({ input }) => {
    const gameEntity = await createGameEntity();
    const result = await gameEntity.scan.go({
      cursor: input.cursor,
      count: input.limit,
    });


    return {
      items: result.data as IGame[],
      cursor: result.cursor,
    };
  });


export const saveGame = publicProcedure
  .input(GameSchema.omit({ lastUpdated: true }))
  .output(GameSchema)
  .mutation(async ({ input }) => {
    const gameEntity = await createGameEntity();


    const result = await gameEntity.put(input).go();
    return result.data as IGame;
  });

Elimina el archivo echo.ts (de packages/game-api/src/procedures) ya que no lo usaremos en este proyecto.

Configuración del enrutador

Sección titulada «Configuración del enrutador»

Después de definir nuestros procedimientos, para conectarlos a nuestra API, actualiza el siguiente archivo:

import { t } from './init.js';
import { queryActions } from './procedures/actions.js';
import { queryGames, saveGame } from './procedures/games.js';
import { queryInventory } from './procedures/inventory.js';


export const router = t.router;


export const appRouter = router({
  actions: router({
    query: queryActions,
  }),
  games: router({
    query: queryGames,
    save: saveGame,
  }),
  inventory: router({
    query: queryInventory,
  }),
});


export type AppRouter = typeof appRouter;

Tarea 2: Crear un servidor MCP de inventario

Sección titulada «Tarea 2: Crear un servidor MCP de inventario»

Creemos un servidor MCP que permitirá a nuestro agente gestionar elementos en el inventario de un jugador.

Definiremos las siguientes herramientas para nuestro agente:

  • list-inventory-items para recuperar los elementos actuales del inventario del jugador
  • add-to-inventory para agregar elementos al inventario del jugador
  • remove-from-inventory para eliminar elementos del inventario del jugador

Para ahorrar tiempo, definiremos todas las herramientas en línea:

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import z from 'zod';
import { createInventoryEntity } from '@dungeon-adventure/dungeon-db';


/**
 * Create the MCP Server
 */
export const createServer = async () => {
  const server = new McpServer({
    name: 'inventory-mcp-server',
    version: '1.0.0',
  });


  server.registerTool(
    'list-inventory-items',
    {
      description: "List items in the player's inventory. Leave cursor blank unless you are requesting subsequent pages",
      inputSchema: {
        playerName: z.string(),
        cursor: z.string().optional(),
      },
    },
    async ({ playerName }) => {
      const inventory = await createInventoryEntity();
      const results = await inventory.query
        .primary({
          playerName,
        })
        .go();


      return {
        content: [{ type: 'text' as const, text: JSON.stringify(results) }],
      };
    },
  );


  server.registerTool(
    'add-to-inventory',
    {
      description: "Add an item to the player's inventory. Quantity defaults to 1 if omitted.",
      inputSchema: {
        playerName: z.string(),
        itemName: z.string(),
        emoji: z.string(),
        quantity: z.number().optional().default(1),
      },
    },
    async ({ playerName, itemName, emoji, quantity = 1 }) => {
      const inventory = await createInventoryEntity();
      await inventory
        .put({
          playerName,
          itemName,
          quantity,
          emoji,
        })
        .go();


      return {
        content: [
          {
            type: 'text' as const,
            text: `Added ${itemName} (x${quantity}) to inventory`,
          },
        ],
      };
    },
  );


  server.registerTool(
    'remove-from-inventory',
    {
      description: "Remove an item from the player's inventory. If quantity is omitted, all items are removed.",
      inputSchema: {
        playerName: z.string(),
        itemName: z.string(),
        quantity: z.number().optional(),
      },
    },
    async ({ playerName, itemName, quantity }) => {
      const inventory = await createInventoryEntity();


      // If quantity is omitted, remove the entire item
      if (quantity === undefined) {
        try {
          await inventory.delete({ playerName, itemName }).go();
          return {
            content: [
              { type: 'text' as const, text: `${itemName} removed from inventory.` },
            ],
          };
        } catch {
          return {
            content: [
              { type: 'text' as const, text: `${itemName} not found in inventory` },
            ],
          };
        }
      }


      // If quantity is specified, fetch current quantity and update
      const item = await inventory.get({ playerName, itemName }).go();


      if (!item.data) {
        return {
          content: [
            { type: 'text' as const, text: `${itemName} not found in inventory` },
          ],
        };
      }


      const newQuantity = item.data.quantity - quantity;


      if (newQuantity <= 0) {
        await inventory.delete({ playerName, itemName }).go();
        return {
          content: [
            { type: 'text' as const, text: `${itemName} removed from inventory.` },
          ],
        };
      }


      await inventory
        .put({
          playerName,
          itemName,
          quantity: newQuantity,
          emoji: item.data.emoji,
        })
        .go();


      return {
        content: [
          {
            type: 'text' as const,
            text: `Removed ${itemName} (x${quantity}) from inventory. ${newQuantity} remaining.`,
          },
        ],
      };
    },
  );


  return server;
};

A medida que crezca el número de herramientas, puedes refactorizarlas en archivos separados si lo deseas.

Elimina los directorios tools y resources en packages/inventory/src/mcp-server ya que no se usarán.

Tarea 3: Actualizar la infraestructura

Sección titulada «Tarea 3: Actualizar la infraestructura»

Exponer el bucket de sesión

Sección titulada «Exponer el bucket de sesión»

El constructo del Story Agent ya aprovisiona y escribe en su propio bucket de sesión internamente, pero no lo expone — así que nada fuera del agente puede recibir acceso para leer de él todavía. Dado que queryActions necesita leer el historial de conversación de vuelta, para ilustración y simplicidad expondremos su bucket de sesión interno como una propiedad pública en common/constructs/src/app/agents/story-agent/story-agent.ts:

import { Fn, Lazy, Names, RemovalPolicy, Stack } from 'aws-cdk-lib';
import { Platform } from 'aws-cdk-lib/aws-ecr-assets';
import { Connections, IConnectable } from 'aws-cdk-lib/aws-ec2';
import {
  BlockPublicAccess,
  Bucket,
  BucketEncryption,
  IBucket,
} from 'aws-cdk-lib/aws-s3';
import { Key } from 'aws-cdk-lib/aws-kms';
import {
  CfnDelivery,
  CfnDeliveryDestination,
  CfnDeliverySource,
  LogGroup,
  RetentionDays,
} from 'aws-cdk-lib/aws-logs';
import { Construct } from 'constructs';
import * as path from 'path';
import * as url from 'url';
import {
  AgentRuntimeArtifact,
  ProtocolType,
  Runtime,
  RuntimeProps,
  RuntimeAuthorizerConfiguration,
} from 'aws-cdk-lib/aws-bedrockagentcore';
import {
  PolicyStatement,
  Effect,
  ServicePrincipal,
  IGrantable,
  IPrincipal,
} from 'aws-cdk-lib/aws-iam';
import { IUserPool, IUserPoolClient } from 'aws-cdk-lib/aws-cognito';
import { suppressRules } from '../../../core/checkov.js';
import { RuntimeConfig } from '../../../core/runtime-config.js';
import { findWorkspaceRoot } from '../../../core/workspace.js';


export type StoryAgentProps = Omit<
  RuntimeProps,
  | 'runtimeName'
  | 'protocolConfiguration'
  | 'agentRuntimeArtifact'
  | 'authorizerConfiguration'
> & {
  /**
   * Identity details for Cognito Authentication
   */
  identity: {
    userPool: IUserPool;
    userPoolClient: IUserPoolClient;
  };
  /**
   * Removal policy for the session bucket holding the agent's conversation
   * history. Defaults to retaining it so a stack `destroy` doesn't silently
   * delete session data — set to `RemovalPolicy.DESTROY` for sandbox/CI teardown.
   *
   * @default RemovalPolicy.RETAIN
   */
  readonly sessionBucketRemovalPolicy?: RemovalPolicy;
};


export class StoryAgent extends Construct implements IGrantable, IConnectable {
  public readonly dockerImage: AgentRuntimeArtifact;
  public readonly agentCoreRuntime: Runtime;
  /** The S3 bucket backing this agent's session storage — exposed so other constructs (e.g. the Game API) can be granted access to read conversation history back. */
  public readonly sessionBucket: IBucket;
  /** Default Gateway target name for this agent. */
  public readonly agentName = 'story-agent';
  /** Inbound auth — a fronting Gateway uses this to pick its outbound credential. */
  public readonly auth = 'cognito';


  constructor(scope: Construct, id: string, props: StoryAgentProps) {
    super(scope, id);


    const rc = RuntimeConfig.ensure(this);


    // Resolve the bundle output directory containing the Dockerfile and built artifacts
    const bundleDir = path.join(
      findWorkspaceRoot(url.fileURLToPath(new URL(import.meta.url))),
      'dist/packages/story/docker/story-agent',
    );


    this.dockerImage = AgentRuntimeArtifact.fromAsset(bundleDir, {
      platform: Platform.LINUX_ARM64,
    });


    const {
      identity,
      sessionBucketRemovalPolicy = RemovalPolicy.RETAIN,
      ...restProps
    } = props ?? {};


    const sessionKey = new Key(this, 'SessionKey', {
      enableKeyRotation: true,
    });


    // Allow CloudWatch Logs to use the session key for server access log delivery.
    const stack = Stack.of(this);
    sessionKey.addToResourcePolicy(
      new PolicyStatement({
        effect: Effect.ALLOW,
        principals: [
          new ServicePrincipal(`logs.${stack.region}.amazonaws.com`),
        ],
        actions: [
          'kms:Encrypt',
          'kms:Decrypt',
          'kms:ReEncrypt*',
          'kms:GenerateDataKey*',
          'kms:DescribeKey',
        ],
        resources: ['*'],
        conditions: {
          ArnLike: {
            'kms:EncryptionContext:aws:logs:arn': `arn:aws:logs:${stack.region}:${stack.account}:log-group:*`,
          },
        },
      }),
    );


    const sessionAccessLogs = new LogGroup(this, 'SessionAccessLogs', {
      retention: RetentionDays.ONE_YEAR,
      encryptionKey: sessionKey,
      removalPolicy: RemovalPolicy.DESTROY,
    });


    const sessionBucket = new Bucket(this, 'SessionBucket', {
      enforceSSL: true,
      removalPolicy: sessionBucketRemovalPolicy,
      encryption: BucketEncryption.KMS,
      encryptionKey: sessionKey,
      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,
    });
    this.sessionBucket = sessionBucket;
    suppressRules(
      sessionBucket,
      ['CKV_AWS_21'],
      'Session data does not need versioning enabled',
    );
    suppressRules(
      sessionBucket,
      ['CKV2_AWS_61'],
      'Lifecycle configuration not required for session data',
    );
    suppressRules(
      sessionBucket,
      ['CKV_AWS_144'],
      'Cross-region replication not required for session data',
    );
    suppressRules(
      sessionBucket,
      ['CKV2_AWS_62'],
      'Event notifications not required for session data',
    );
    suppressRules(
      sessionBucket,
      ['CKV_AWS_18'],
      'Server access logs are delivered to CloudWatch Logs',
    );


    const sessionAccessLogsSource: CfnDeliverySource = new CfnDeliverySource(
      this,
      'SessionAccessLogsSource',
      {
        name: Lazy.string({
          produce: () =>
            Names.uniqueResourceName(sessionAccessLogsSource, {
              maxLength: 60,
            }),
        }),
        logType: 'S3_SERVER_ACCESS_LOGS',
        resourceArn: sessionBucket.bucketArn,
      },
    );
    const sessionBucketPolicy = sessionBucket.policy;
    if (sessionBucketPolicy) {
      sessionAccessLogsSource.node.addDependency(sessionBucketPolicy);
    }
    const sessionAccessLogsDestination: CfnDeliveryDestination =
      new CfnDeliveryDestination(this, 'SessionAccessLogsDestination', {
        name: Lazy.string({
          produce: () =>
            Names.uniqueResourceName(sessionAccessLogsDestination, {
              maxLength: 60,
            }),
        }),
        destinationResourceArn: sessionAccessLogs.logGroupArn,
      });
    const sessionAccessLogsDelivery = new CfnDelivery(
      this,
      'SessionAccessLogsDelivery',
      {
        deliverySourceName: sessionAccessLogsSource.name,
        deliveryDestinationArn: sessionAccessLogsDestination.attrArn,
      },
    );
    sessionAccessLogsDelivery.addDependency(sessionAccessLogsSource);


    this.agentCoreRuntime = new Runtime(this, 'StoryAgent', {
      runtimeName: Lazy.string({
        produce: () =>
          Names.uniqueResourceName(this.agentCoreRuntime, { maxLength: 40 }),
      }),
      protocolConfiguration: ProtocolType.HTTP,
      agentRuntimeArtifact: this.dockerImage,
      authorizerConfiguration: RuntimeAuthorizerConfiguration.usingCognito(
        identity.userPool,
        [identity.userPoolClient],
      ),
      // Receive the caller's Authorization header (validated by the authorizer).
      requestHeaderConfiguration: {
        allowlistedHeaders: ['Authorization'],
      },
      ...restProps,
      environmentVariables: {
        RUNTIME_CONFIG_APP_ID: rc.appConfigApplicationId,
        ...restProps?.environmentVariables,
      },
    });


    // Grant access for the agent to invoke bedrock models
    this.agentCoreRuntime.addToRolePolicy(
      new PolicyStatement({
        actions: [
          'bedrock:InvokeModel',
          'bedrock:InvokeModelWithResponseStream',
        ],
        resources: [
          'arn:aws:bedrock:*:*:foundation-model/*',
          'arn:aws:bedrock:*:*:inference-profile/*',
        ],
      }),
    );


    sessionBucket.grantReadWrite(this.agentCoreRuntime);


    rc.grantReadAppConfig(this.agentCoreRuntime);


    rc.set('agentcore', 'agentRuntimes', {
      ...rc.get('agentcore').agentRuntimes,
      StoryAgent: {
        arn: this.agentCoreRuntime.agentRuntimeArn,
        session: {
          bucketName: sessionBucket.bucketName,
        },
      },
    });


    rc.set('connection', 'agentRuntimes', {
      ...rc.get('connection').agentRuntimes,
      StoryAgent: this.agentCoreRuntime.agentRuntimeArn,
    });
  }


  /**
   * The principal to grant permissions to.
   */
  public get grantPrincipal(): IPrincipal {
    return this.agentCoreRuntime.grantPrincipal;
  }


  /**
   * Network connections for this agent runtime.
   */
  public get connections(): Connections {
    return this.agentCoreRuntime.connections;
  }


  /**
   * The HTTPS invocation URL of the runtime.
   */
  public get invocationUrl(): string {
    // The URL must URL-encode the runtime ARN (':' -> '%3A', '/' -> '%2F').
    // The ARN is a CDK token, so encode at deploy time via Fn.join/Fn.split.
    const encodedArn = Fn.join(
      '%2F',
      Fn.split(
        '/',
        Fn.join('%3A', Fn.split(':', this.agentCoreRuntime.agentRuntimeArn)),
      ),
    );
    return `https://bedrock-agentcore.${Stack.of(this).region}.amazonaws.com/runtimes/${encodedArn}/invocations?qualifier=DEFAULT`;
  }
}

Conectar el stack

Sección titulada «Conectar el stack»

El constructo DungeonDb generado por ts#dynamodb ya aprovisiona nuestra tabla, así que solo necesitamos instanciarlo en nuestro stack y otorgar a la API del juego y al servidor MCP de inventario los permisos que necesitan. Actualiza packages/infra/src/stacks/application-stack.ts de la siguiente manera:

import {
  DungeonDb,
  GameApi,
  GameUI,
  InventoryMcpServer,
  StoryAgent,
  UserIdentity,
} from '@dungeon-adventure/common-constructs';
import { Stack, StackProps, CfnOutput, RemovalPolicy } from 'aws-cdk-lib';
import { Construct } from 'constructs';


export class ApplicationStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);


    const userIdentity = new UserIdentity(this, 'UserIdentity');


    // Sandbox-friendly: allow the table to be deleted with the stack.
    const dungeonDb = new DungeonDb(this, 'DungeonDb', {
      deletionProtection: false,
      removalPolicy: RemovalPolicy.DESTROY,
    });


    const gameApi = new GameApi(this, 'GameApi', {
      integrations: GameApi.defaultIntegrations(this).build(),
    });


    dungeonDb.grantReadData(gameApi.integrations['games.query'].handler);
    dungeonDb.grantReadData(gameApi.integrations['inventory.query'].handler);
    dungeonDb.grantReadWriteData(gameApi.integrations['games.save'].handler);


    const mcpServer = new InventoryMcpServer(this, 'InventoryMcpServer');
    dungeonDb.grantReadWriteData(mcpServer.agentCoreRuntime);


    // Use Cognito for user authentication with the agent
    const storyAgent = new StoryAgent(this, 'StoryAgent', {
      identity: userIdentity,
    });
    // The agent's own session bucket already persists conversation history via
    // S3SessionManager; grant the Game API read access so it can replay it.
    storyAgent.sessionBucket.grantRead(
      gameApi.integrations['actions.query'].handler,
    );


    new CfnOutput(this, 'StoryAgentArn', {
      value: storyAgent.agentCoreRuntime.agentRuntimeArn,
    });
    new CfnOutput(this, 'InventoryMcpArn', {
      value: mcpServer.agentCoreRuntime.agentRuntimeArn,
    });


    // Grant the agent permissions to invoke our mcp server
    mcpServer.grantInvokeAccess(storyAgent);


    // Grant the authenticated role access to invoke the api
    gameApi.grantInvokeAccess(userIdentity.identityPool.authenticatedRole);


    new GameUI(this, 'GameUI');
  }
}

Tarea 4: Probar la API del juego localmente

Sección titulada «Tarea 4: Probar la API del juego localmente»

No es necesario desplegar en AWS para probar nuestra API — el objetivo dev ejecuta la API del juego contra DynamoDB Local. Debido a que conectamos la API del juego al proyecto DungeonDb en el Módulo 1, este objetivo también inicia DynamoDB Local automáticamente.

Primero, corrige cualquier problema de lint:

Terminal window
pnpm lint

Luego construye la base de código:

Terminal window
pnpm build

Iniciar el servidor local

Sección titulada «Iniciar el servidor local»

Inicia la API del juego localmente con el objetivo dev, que también arranca DynamoDB Local:

Terminal window
pnpm nx dev game-api

Probar la API

Sección titulada «Probar la API»

Una vez que tu servidor esté en funcionamiento, consulta la lista (vacía) de juegos:

Ventana de terminal
curl -X GET 'http://localhost:2022/games.query?input=%7B%7D'

Verás una lista vacía:

{"result":{"data":{"items":[],"cursor":null}}}

Ahora guarda un juego:

Ventana de terminal
curl -X POST 'http://localhost:2022/games.save' \
  -H 'Content-Type: application/json' \
  -d '{"playerName":"Alice","genre":"zombie"}'

El guardado devuelve el juego persistido (con la marca de tiempo lastUpdated que la entidad establece por ti):

{"result":{"data":{"playerName":"Alice","genre":"zombie","lastUpdated":"..."}}}

Consulta nuevamente para confirmar que está persistido en DynamoDB Local:

Ventana de terminal
curl -X GET 'http://localhost:2022/games.query?input=%7B%7D'

Esta respuesta ahora incluye el juego guardado:

{"result":{"data":{"items":[{"playerName":"Alice","genre":"zombie","lastUpdated":"..."}],"cursor":null}}}

Puedes detener el servidor local (Ctrl+C) una vez que hayas terminado.

Tarea 5: Probar el servidor MCP de inventario localmente

Sección titulada «Tarea 5: Probar el servidor MCP de inventario localmente»

Podemos probar las herramientas del servidor MCP con el MCP Inspector usando el objetivo generado mcp-server-inspect:

Terminal window
pnpm nx mcp-server-inspect inventory

Esto sirve el servidor MCP localmente (arrancando DynamoDB Local también) y lanza el MCP Inspector en http://localhost:6274 preconfigurado para conectarse a él. Haz clic en Connect, cambia a la pestaña Tools, haz clic en List Tools, y prueba add-to-inventory (por ejemplo, playerName: Alice, itemName: Rusty Sword, emoji: ⚔️) seguido de list-inventory-items para verlo persistido en DynamoDB Local. Detén el servidor (Ctrl+C) cuando hayas terminado.

¡Felicitaciones, has construido y probado tu primera API tRPC y servidor MCP contra una tabla DynamoDB local! 🎉🎉🎉