TypeScript MCP Server

Genera un server TypeScript Model Context Protocol (MCP) per fornire contesto ai Large Language Model (LLM), e opzionalmente distribuiscilo su Amazon Bedrock AgentCore.

Cos’è MCP?

Il Model Context Protocol (MCP) è uno standard aperto che consente agli assistenti AI di interagire con strumenti e risorse esterne. Fornisce un modo coerente per gli LLM di:

• Eseguire strumenti (funzioni) che eseguono azioni o recuperano informazioni
• Accedere a risorse che forniscono contesto o dati

Utilizzo

Generare un MCP Server

Puoi generare un server MCP TypeScript in due modi:

Esegui questo generatore@aws/nx-plugin:ts#mcp-server

CLI

pnpm

$ pnpm nx g @aws/nx-plugin:ts#mcp-server

yarn

$ yarn nx g @aws/nx-plugin:ts#mcp-server

npm

$ npx nx g @aws/nx-plugin:ts#mcp-server

bun

$ bunx nx g @aws/nx-plugin:ts#mcp-server

VSCode

1. Installa il Nx Console VSCode Plugin se non l'hai già fatto
2. Apri la console Nx in VSCode
3. Clicca su Generate (UI) nella sezione "Common Nx Commands"
4. Cerca @aws/nx-plugin - ts#mcp-server
5. Compila i parametri richiesti
6. Clicca su Generate

Componi il tuo comando6

projectObbligatorio

authinfra = agentcore | agentcore-ecr

iamcognito

iac

inheritcdkterraform

infra

agentcoreagentcore-ecrnone

name

preferInstallDependencies

true

--dry-runPuoi anche eseguire una prova per vedere quali file verrebbero modificati

Prerequisito del Progetto

Prima utilizza il generatore ts#project per creare un progetto a cui aggiungere il tuo MCP server.

Opzioni

Opzioni del generatore6 opzioni

projectObbligatoriostring

Il progetto a cui aggiungere un server MCP

authenuminfra = agentcore | agentcore-ecrPredefinito: iam

Il metodo utilizzato per autenticare con il tuo server MCP. Applicabile solo quando infra è impostato (ignorato quando infra è none).

iamcognito

iacenumPredefinito: inherit

Il provider IaC preferito. Per impostazione predefinita viene ereditato dalla selezione iniziale.

inheritcdkterraform

infraenumPredefinito: agentcore

Il tipo di infrastruttura per ospitare il tuo server MCP. agentcore distribuisce il tuo codice come zip in un runtime gestito da AgentCore per il ciclo di build e deploy più veloce. agentcore-ecr costruisce e ospita un'immagine container invece, per il controllo a livello di sistema operativo o una pipeline container consolidata. Seleziona none per nessun hosting.

agentcoreagentcore-ecrnone

namestring

Il nome del tuo server MCP (default: mcp-server)

preferInstallDependenciesbooleanPredefinito: true

Se preferire l'installazione delle dipendenze dopo l'esecuzione del generatore. Impostare su false per rimandare l'installazione quando si eseguono più generatori in batch (l'installazione viene comunque eseguita se necessaria affinché i generatori successivi possano calcolare il grafo dei progetti Nx); installare una volta alla fine.

Output del Generatore

Il generatore aggiungerà i seguenti file al tuo progetto TypeScript esistente:

• Directoryyour-project/

  • Directorysrc/

    • Directorymcp-server/ (o nome personalizzato se specificato)

      • index.ts Esporta il tuo server
      • server.ts Definizione principale del server
      • stdio.ts Punto di ingresso per il trasporto STDIO, utile per semplici MCP server locali
      • http.ts Punto di ingresso per il trasporto HTTP Streamable, utile per ospitare il tuo MCP server
      • Directorytools/

        • divide.ts Strumento di esempio
      • Directoryresources/

        • sample-guidance.ts Risorsa di esempio
      • Dockerfile Definizione dell’immagine del container (solo quando infra è agentcore-ecr)
  • project.json Aggiornato con il target serve dell’MCP server

Infrastruttura

L’opzione infra seleziona come il tuo codice viene impacchettato e ospitato su Amazon Bedrock AgentCore Runtime:

• agentcore (predefinito) utilizza il deployment diretto del codice: il tuo codice compilato viene impacchettato come un file .zip, caricato su S3 ed eseguito su un runtime del linguaggio gestito da AgentCore. Non c’è alcuna immagine container da costruire, nessun repository ECR da gestire e nessuna immagine da inviare, il che rende il ciclo di build e deploy sostanzialmente più veloce.
• agentcore-ecr costruisce un’immagine container arm64 da un Dockerfile fornito e la ospita dal registro condiviso core/asset-ecr, insieme a tutti gli altri container nel workspace. Scegli questa opzione quando hai bisogno di controllare l’immagine del sistema operativo — ad esempio per installare librerie di sistema native — o quando hai una pipeline di container consolidata. Questa opzione fornisce inoltre un target di scansione immagini Trivy (vedi Image Scanning di seguito).
• none non genera alcuna infrastruttura, quindi il progetto può essere eseguito solo localmente.

infra = agentcore | agentcore-ecr

Poiché questo generatore fornisce infrastruttura come codice basata sul tuo iac scelto, creerà un progetto in packages/common che include i costrutti CDK o i moduli Terraform pertinenti.

Il progetto comune di infrastruttura come codice è strutturato come segue:

CDK

• Directorypackages/common/constructs

  • Directorysrc

    • Directoryapp/ Constructs for infrastructure specific to a project/generator

      • …
    • Directorycore/ Generic constructs which are reused by constructs in app

      • …
    • index.ts Entry point exporting constructs from app
  • project.json Project build targets and configuration

Progetto Generato

Questo progetto è generato utilizzando il generatore ts#project e quindi configura gli stessi target di build.

Terraform

• Directorypackages/common/terraform

  • Directorysrc

    • Directoryapp/ Terraform modules for infrastructure specific to a project/generator

      • …
    • Directorycore/ Generic modules which are reused by modules in app

      • …
  • project.json Project build targets and configuration

Progetto Generato

Questo progetto è generato utilizzando il generatore terraform#project e quindi configura gli stessi target di build.

Per il deployment del tuo MCP Server, vengono generati i seguenti file:

CDK

• Directorypackages/common/constructs/src

  • Directoryapp

    • Directorymcp-servers

      • Directory<mcp-server-name>

        • <mcp-server-name>.ts CDK construct for deploying your MCP Server

Terraform

• Directorypackages/common/terraform/src

  • Directoryapp

    • Directorymcp-servers

      • Directory<mcp-server-name>

        • <mcp-server-name>.tf Module for deploying your MCP Server
  • Directorycore

    • Directoryagent-core

      • runtime.tf Generic module for deploying to Bedrock AgentCore Runtime
    • Directoryagent-core-code (when infra is agentcore)

      • runtime.tf Packages your MCP Server’s code and delegates to agent-core
    • Directoryagent-core-container (when infra is agentcore-ecr)

      • runtime.tf Builds and publishes your MCP Server’s image and delegates to agent-core

infra = none

Se hai selezionato none per infra, non vengono generati costrutti CDK o moduli Terraform — il server MCP è configurato solo per l’uso locale STDIO / HTTP. L’opzione auth viene ignorata in questa modalità poiché non c’è un endpoint ospitato da autenticare.

Architettura

AgentCore Runtime

Quando viene distribuito su Bedrock AgentCore Runtime, il codice del tuo server viene impacchettato come zip ed eseguito nel runtime gestito di AgentCore. Gli assistenti AI invocano l’endpoint del data plane di AgentCore Runtime, che inoltra le chiamate tools/* e resources/* al tuo server tramite il trasporto HTTP streamable.

Loading the diagram…

AgentCore Runtime (container)

Con infra: agentcore-ecr, il server MCP viene costruito in un’immagine container, caricato su Amazon ECR ed eseguito in AgentCore Runtime. Questo ti offre il controllo a livello di sistema operativo sull’ambiente di runtime, al costo di un ciclo di build e deploy più lungo rispetto al packaging zip sopra descritto.

Loading the diagram…

None (local only)

Con infra: none, non viene generata alcuna infrastruttura AWS. Il server MCP è configurato solo per i trasporti STDIO e HTTP locali, ed è utilizzato da assistenti AI in esecuzione sulla stessa macchina.

Loading the diagram…

Lavorare con il Tuo MCP Server

Aggiungere Strumenti

Gli strumenti sono funzioni che l’assistente AI può chiamare per eseguire azioni. Ogni strumento risiede nel proprio file sotto tools/ che esporta una funzione register<Name>Tool, che poi chiami da server.ts. Ad esempio, aggiungi tools/my-tool.ts:

tools/my-tool.ts

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { z } from 'zod';

export const registerMyTool = (server: McpServer) => {
  server.registerTool(
    'toolName',
    {
      description: 'tool description',
      // Input schema using Zod
      inputSchema: { param1: z.string(), param2: z.number() },
    },
    async ({ param1, param2 }) => {
      // Tool implementation
      const result = `${param1} ${param2}`;
      return {
        content: [{ type: 'text' as const, text: result }],
      };
    },
  );
};

Poi registralo all’interno di createServer in server.ts:

server.ts

import { registerMyTool } from './tools/my-tool.js';

export const createServer = async () => {
  const server = new McpServer({ name: 'my-server', version: '1.0.0' });

  registerMyTool(server);

  return server;
};

Aggiungere Risorse

Le risorse forniscono contesto all’assistente AI. Come gli strumenti, ogni risorsa risiede nel proprio file sotto resources/ che esporta una funzione register<Name>Resource chiamata da server.ts. Puoi aggiungere risorse statiche da file o risorse dinamiche:

resources/my-resource.ts

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';

const fetchSomeData = async (): Promise<string> => 'some dynamic context';

export const registerMyResource = (server: McpServer) => {
  const exampleContext = 'some context to return';

  server.registerResource(
    'resource-name',
    'example://resource',
    {},
    async (uri) => ({
      contents: [{ uri: uri.href, text: exampleContext }],
    }),
  );

  // Dynamic resource
  server.registerResource(
    'dynamic-resource',
    'dynamic://resource',
    {},
    async (uri) => {
      const data = await fetchSomeData();
      return {
        contents: [{ uri: uri.href, text: data }],
      };
    },
  );
};

Registralo all’interno di createServer in server.ts allo stesso modo di uno strumento:

server.ts

import { registerMyResource } from './resources/my-resource.js';

export const createServer = async () => {
  const server = new McpServer({ name: 'my-server', version: '1.0.0' });

  registerMyResource(server);

  return server;
};

Configurazione con Assistenti AI

File di Configurazione

La maggior parte degli assistenti AI che supportano MCP utilizza un approccio di configurazione simile. Dovrai creare o aggiornare un file di configurazione con i dettagli del tuo server MCP:

{
  "mcpServers": {
    "your-mcp-server": {
      "command": "npx",
      "args": ["tsx", "/path/to/your-mcp-server/stdio.ts"]
    }
  }
}

Risoluzione del Percorso

Se ricevi un errore come ENOENT npx durante la connessione al tuo server, potrebbe essere necessario specificare il percorso completo di npx, che puoi ottenere eseguendo which npx nel tuo terminale.

Hot Reload

Durante lo sviluppo del tuo server MCP, potresti voler configurare il flag --watch in modo che l’assistente AI veda sempre le versioni più recenti di strumenti/risorse:

{
  "mcpServers": {
    "your-mcp-server": {
      "command": "npx",
      "args": ["tsx", "--watch", "/path/to/your-mcp-server/stdio.ts"]
    }
  }
}

Aggiornamento degli Strumenti

Se aggiungi nuovi strumenti o risorse potrebbe essere necessario aggiornare il tuo server MCP nell’assistente AI.

Configurazione Specifica per Assistente

Si prega di fare riferimento alla seguente documentazione per configurare MCP con specifici Assistenti AI:

• Kiro
• Kiro CLI
• Claude Code
• Cursor
• Codex
• Cline
• Roo Code

Configurazione del Workspace

Alcuni Assistenti AI, come Kiro, consentono di specificare la configurazione del server MCP a livello di workspace, il che è particolarmente utile per definire i server MCP rilevanti per un particolare progetto.

Eseguire il Tuo MCP Server

Sviluppo Locale

Per eseguire il tuo server MCP (e tutto ciò che è connesso ad esso, come un database locale) localmente, usa il target dev del progetto:

pnpm

pnpm nx dev your-project

yarn

yarn nx dev your-project

npm

npx nx dev your-project

bun

bunx nx dev your-project

Se hai aggiunto più componenti al tuo progetto (server MCP, agenti, ecc.), questo li avvia tutti. Per eseguire solo questo server MCP, punta al suo target <your-server-name>-dev:

pnpm

pnpm nx your-server-name-dev your-project

yarn

yarn nx your-server-name-dev your-project

npm

npx nx your-server-name-dev your-project

bun

bunx nx your-server-name-dev your-project

Inspector

Il generatore configura un target denominato <your-server-name>-inspect, che avvia il tuo server MCP localmente (tramite il target <your-server-name>-dev, incluse eventuali dipendenze connesse come un database locale) e lancia l’MCP Inspector preconfigurato per connettersi ad esso tramite trasporto HTTP Streamable.

pnpm

pnpm nx your-server-name-inspect your-project

yarn

yarn nx your-server-name-inspect your-project

npm

npx nx your-server-name-inspect your-project

bun

bunx nx your-server-name-inspect your-project

Questo avvierà l’inspector su http://localhost:6274. Inizia cliccando sul pulsante “Connect”.

Consiglio

Per ispezionare il server utilizzando il trasporto STDIO invece, usa il target <your-server-name>-inspect-stdio, che lancia l’inspector contro un’istanza STDIO del tuo server.

STDIO

Il modo più semplice per testare e utilizzare un server MCP è utilizzare l’inspector o configurarlo con un assistente AI (come sopra).

Puoi tuttavia eseguire il tuo server con trasporto STDIO direttamente utilizzando il target <your-server-name>-serve-stdio.

pnpm

pnpm nx your-server-name-serve-stdio your-project

yarn

yarn nx your-server-name-serve-stdio your-project

npm

npx nx your-server-name-serve-stdio your-project

bun

bunx nx your-server-name-serve-stdio your-project

Questo comando utilizza tsx --watch per riavviare automaticamente il server quando i file cambiano.

Streamable HTTP

Se desideri eseguire il tuo server MCP localmente utilizzando trasporto HTTP Streamable, puoi utilizzare il target <your-server-name>-serve.

pnpm

pnpm nx your-server-name-serve your-project

yarn

yarn nx your-server-name-serve your-project

npm

npx nx your-server-name-serve your-project

bun

bunx nx your-server-name-serve your-project

Questo comando utilizza tsx --watch per riavviare automaticamente il server quando i file cambiano.

infra = agentcore | agentcore-ecr

Distribuire il Tuo MCP Server su Bedrock AgentCore Runtime

Infrastructure as Code

Se hai selezionato agentcore o agentcore-ecr per infra, viene generata l’infrastruttura CDK o Terraform rilevante che puoi utilizzare per distribuire il tuo server MCP su Amazon Bedrock AgentCore Runtime.

CDK

Viene generato un costrutto CDK per il tuo server MCP, denominato in base al name che hai scelto durante l’esecuzione del generatore, o <ProjectName>McpServer per impostazione predefinita.

Puoi utilizzare questo costrutto CDK in un’applicazione CDK:

import { MyProjectMcpServer } from '@my-scope/common-constructs';

export class ExampleStack extends Stack {
  constructor(scope: Construct, id: string) {
    // Add the MCP server to your stack
    new MyProjectMcpServer(this, 'MyProjectMcpServer');
  }
}

Costrutto CDK

Questo costrutto utilizza il modulo aws-cdk-lib/aws-bedrockagentcore.

Terraform

Viene generato un modulo Terraform per te, denominato in base al name che hai scelto durante l’esecuzione del generatore, o <ProjectName>-mcp-server per impostazione predefinita.

Passa gli output del modulo runtime_config_appconfig condiviso nel modulo del server MCP, insieme all’archivio di artefatti condiviso utilizzato dal suo packaging. Con il packaging agentcore predefinito, il codice del server viene preparato nel bucket di asset condiviso, quindi istanzia il modulo core/asset-bucket una volta per distribuzione, come già fanno i moduli Lambda e API:

module "asset_bucket" {
  source = "../../common/terraform/src/core/asset-bucket"
}

module "my_project_mcp_server" {
  source = "../../common/terraform/src/app/mcp-servers/my-project-mcp-server"

  appconfig_application_id  = module.runtime_config_appconfig.application_id
  appconfig_application_arn = module.runtime_config_appconfig.application_arn

  asset_bucket_name = module.asset_bucket.bucket_name
  asset_bucket_arn  = module.asset_bucket.bucket_arn
}

Con agentcore-ecr l’immagine del server viene invece pubblicata nel registro di asset condiviso, quindi passa gli output di core/asset-ecr anziché quelli del bucket. Un registro serve tutti i container nel workspace, quindi nessun server MCP necessita di un proprio repository:

module "asset_ecr" {
  source = "../../common/terraform/src/core/asset-ecr"
}

module "my_project_mcp_server" {
  source = "../../common/terraform/src/app/mcp-servers/my-project-mcp-server"

  appconfig_application_id  = module.runtime_config_appconfig.application_id
  appconfig_application_arn = module.runtime_config_appconfig.application_arn

  asset_ecr_repository_url = module.asset_ecr.repository_url
  asset_ecr_repository_arn = module.asset_ecr.repository_arn
}

Autenticazione

Il generatore fornisce un’opzione auth per configurare l’autenticazione per il tuo server MCP. Puoi scegliere tra autenticazione IAM (predefinita) o Cognito durante la generazione del tuo server MCP.

IAM

Per impostazione predefinita, il tuo server MCP sarà protetto utilizzando l’autenticazione IAM, semplicemente distribuiscilo senza alcun argomento:

CDK

import { MyProjectMcpServer } from '@my-scope/common-constructs';

export class ExampleStack extends Stack {
  constructor(scope: Construct, id: string) {
    new MyProjectMcpServer(this, 'MyProjectMcpServer');
  }
}

Puoi concedere l’accesso per invocare il tuo server MCP su Bedrock AgentCore Runtime utilizzando il metodo grantInvokeAccess. Ad esempio, potresti desiderare che un agente generato con il generatore py#agent chiami il tuo server MCP:

import { MyProjectAgent, MyProjectMcpServer } from '@my-scope/common-constructs';

export class ExampleStack extends Stack {
  constructor(scope: Construct, id: string) {
    const agent = new MyProjectAgent(this, 'MyProjectAgent');
    const mcpServer = new MyProjectMcpServer(this, 'MyProjectMcpServer');

    mcpServer.grantInvokeAccess(agent);
  }
}

Terraform

# MCP Server
module "my_project_mcp_server" {
  # Relative path to the generated module in the common/terraform project
  source = "../../common/terraform/src/app/mcp-servers/my-project-mcp-server"

  appconfig_application_id  = module.runtime_config_appconfig.application_id
  appconfig_application_arn = module.runtime_config_appconfig.application_arn
}

Per concedere l’accesso per invocare il tuo server MCP, dovrai aggiungere una policy come la seguente, facendo riferimento all’output module.my_project_mcp_server.agent_core_runtime_arn:

{
  Effect = "Allow"
  Action = [
    "bedrock-agentcore:InvokeAgentRuntime"
  ]
  Resource = [
    module.my_project_mcp_server.agent_core_runtime_arn,
    "${module.my_project_mcp_server.agent_core_runtime_arn}/*"
  ]
}

Autenticazione Cognito

Quando selezioni l’autenticazione Cognito, il generatore configura il server MCP per utilizzare Cognito per l’autenticazione.

CDK

Il costrutto generato accetta una prop identity che configura l’autenticazione Cognito:

import { MyProjectMcpServer, UserIdentity } from '@my-scope/common-constructs';

export class ExampleStack extends Stack {
  constructor(scope: Construct, id: string) {
    const identity = new UserIdentity(this, 'Identity');

    new MyProjectMcpServer(this, 'MyProjectMcpServer', {
      identity,
    });
  }
}

Il costrutto UserIdentity può essere generato utilizzando il generatore ts#website#auth, oppure puoi creare il tuo UserPool e UserPoolClient CDK.

Terraform

Il modulo generato accetta le variabili user_pool_id e user_pool_client_ids per l’autenticazione Cognito:

module "user_identity" {
  source = "../../common/terraform/src/core/user-identity"
}

module "my_project_mcp_server" {
  source = "../../common/terraform/src/app/mcp-servers/my-project-mcp-server"

  appconfig_application_id  = module.runtime_config_appconfig.application_id
  appconfig_application_arn = module.runtime_config_appconfig.application_arn

  user_pool_id         = module.user_identity.user_pool_id
  user_pool_client_ids = [module.user_identity.user_pool_client_id]
}

Provider OIDC personalizzati

Se hai bisogno di autenticazione JWT personalizzata con un provider OIDC non-Cognito, puoi modificare direttamente il costrutto CDK o il modulo Terraform generato per il tuo server MCP. Nota che il generatore di connessioni supporterà solo l’autenticazione IAM o Cognito.

Best practice di sicurezza

Quando implementi la logica di business del tuo server MCP, rivedi le best practice di sicurezza di Bedrock AgentCore Runtime.

Target Bundle

Il generatore configura automaticamente un target bundle che utilizza Rolldown per creare un pacchetto di distribuzione:

pnpm

pnpm nx bundle <project-name>

yarn

yarn nx bundle <project-name>

npm

npx nx bundle <project-name>

bun

bunx nx bundle <project-name>

La configurazione di Rolldown si trova in rolldown.config.ts, con una voce per ogni bundle da generare. Rolldown gestisce la creazione di più bundle in parallelo se definiti.

Configurazione Personalizzata

Puoi modificare la configurazione di Rolldown in rolldown.config.ts, ad esempio se hai dipendenze che si basano su percorsi di file e non possono essere raggruppate in bundle, puoi aggiungerle all’elenco dei moduli external.

Il target bundle utilizza http.ts come punto di ingresso per il server MCP HTTP Streamable da ospitare su Bedrock AgentCore Runtime.

infra = agentcore

Target Package

Il generatore configura un target <your-server-name>-package che assembla il pacchetto di codice distribuibile: il index.js in bundle più un’installazione vendorizzata di AWS Distro for OpenTelemetry, che AgentCore richiede sia presente nel pacchetto. L’infrastruttura generata carica questa directory come un .zip — tramite AgentRuntimeArtifact.fromCodeAsset sotto CDK, o archiviata nel bucket di asset condiviso sotto Terraform.

infra = agentcore-ecr

Target Docker

Il generatore configura un target <your-server-name>-docker che copia il Dockerfile dalla directory sorgente del tuo server MCP nella directory di output del bundle. Questo co-localizza il Dockerfile con gli artefatti del bundle, consentendo a CDK di costruire l’immagine Docker direttamente utilizzando AgentRuntimeArtifact.fromAsset.

Viene anche generato un target docker che prepara il contesto docker per tutti i server MCP se ne hai definiti più di uno.

Scansione delle Immagini

L’immagine Docker costruita per questo progetto può essere scansionata per vulnerabilità utilizzando Trivy, eseguito dall’immagine Trivy ospitata su ECR.

Un target trivy viene aggiunto al tuo progetto che scansiona l’immagine costruita ed esce con codice diverso da zero se viene trovata qualsiasi vulnerabilità di gravità HIGH o CRITICAL. Il Dockerfile generato utilizza un’immagine base senza vulnerabilità risolvibili note di queste gravità al momento della generazione, e aggiorna gli strumenti inclusi (come npm) per mantenerla tale.

La scansione utilizza lo stesso motore container della tua build dell’immagine (docker o finch), quindi non sono richiesti strumenti aggiuntivi. La scansione non è memorizzata in cache, poiché l’immagine che legge risiede nel motore container anziché su disco — quindi scansiona sempre l’immagine reale e fallisce in modo evidente anziché riportare un successo memorizzato in cache per un’immagine che non è più presente. Ogni esecuzione richiede quindi decine di secondi per immagine e aggiorna il database delle vulnerabilità di Trivy, quindi necessita di accesso alla rete. Lo script root trivy fornito scansiona ogni immagine nel workspace:

pnpm

pnpm trivy

yarn

yarn trivy

npm

npm run trivy

bun

bun trivy

Esegui Trivy in CI

La scansione non è intenzionalmente collegata a build poiché questo può introdurre attriti non necessari durante l’iterazione in fase di sviluppo, dato che il database delle vulnerabilità di Trivy viene continuamente aggiornato con nuovi CVE.

Invece raccomandiamo di eseguire il comando sopra come passaggio dedicato nella tua pipeline CI prima del deployment agli stage di produzione.

Le vulnerabilità non risolvibili vengono ignorate

La scansione viene eseguita con --ignore-unfixed, quindi le vulnerabilità senza una correzione disponibile non fanno fallire la build, poiché non possono essere risolte aggiornando gli strumenti nel tuo Dockerfile — non vengono riportate nell’output della scansione della build. Man mano che vengono divulgate nuove vulnerabilità, il risultato delle scansioni può cambiare nel tempo, quindi rivedi periodicamente l’immagine eseguendo trivy image <your-image> senza il flag, e ricostruisci contro un’immagine base più recente (o aggiungi passaggi container per applicare le patch disponibili) una volta che viene pubblicata una correzione.

Soppressione dei Risultati di Trivy

Potrebbero esserci casi in cui desideri sopprimere una vulnerabilità specifica, ad esempio quando non è ancora disponibile una correzione e hai valutato il rischio come accettabile.

Aggiungi l’ID della vulnerabilità (uno per riga) al file .trivyignore nella root del tuo progetto (cioè accanto al tuo project.json):

.trivyignore

# node-tar arbitrary file write - not exploitable in our usage
CVE-2024-XXXXX

Per maggiori dettagli sul filtraggio dei risultati, consulta la documentazione sul filtraggio di Trivy.

Osservabilità

Il tuo server MCP è configurato automaticamente con l’osservabilità utilizzando AWS Distro for Open Telemetry (ADOT), configurando l’auto-strumentazione nel tuo Dockerfile.

Puoi trovare le tracce nella Console AWS CloudWatch, selezionando “GenAI Observability” nel menu. Nota che affinché le tracce vengano popolate dovrai abilitare Transaction Search.

Per maggiori dettagli, consulta la documentazione AgentCore sull’osservabilità.

Connessioni

Usa il generatore connection per integrare questo progetto con altri nel tuo workspace. Le seguenti connessioni coinvolgono questo progetto:

TypeScript Agent to MCPConnect a TypeScript Agent to an MCP server

Python Agent to MCPConnect a Python Agent to an MCP server

MCP Server to Relational DatabaseConnect a TypeScript MCP Server to an Aurora relational database

MCP Server to TypeScript DynamoDBConnect a TypeScript MCP Server to a DynamoDB table

AgentCore Gateway to MCP ServerAggregate an MCP server behind an AgentCore Gateway