Tenemos que crear un archivo llamado src/filter/http-exception.filter.ts

import {
  ExceptionFilter,
  Catch,
  ArgumentsHost,
  HttpException,
  HttpStatus,
} from '@nestjs/common';
import { Request, Response } from 'express';
import { Prisma } from '../../generated/prisma/client';

@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const request = ctx.getRequest<Request>();

    let status = HttpStatus.INTERNAL_SERVER_ERROR;
    let message: string | string[] = 'Error interno del servidor';

    // Error de NestJS (404, 400, etc.)
    if (exception instanceof HttpException) {
      status = exception.getStatus();
      const exceptionResponse = exception.getResponse();
      message =
        typeof exceptionResponse === 'object'
          ? (exceptionResponse as any).message
          : exceptionResponse;
    }

    // Error de Prisma — constraint unique (email o dni duplicado)
    else if (exception instanceof Prisma.PrismaClientKnownRequestError) {
      if (exception.code === 'P2002') {
        status = HttpStatus.CONFLICT; // 409
        const fields = (exception.meta?.target as string[])?.join(', ');
        message = `Ya existe un registro con ese ${fields}`;
      }
      // Error de FK — registro relacionado no existe
      else if (exception.code === 'P2003') {
        status = HttpStatus.BAD_REQUEST; // 400
        message = 'El registro relacionado no existe';
      }
      // Registro no encontrado al hacer update/delete
      else if (exception.code === 'P2025') {
        status = HttpStatus.NOT_FOUND; // 404
        message = 'Registro no encontrado';
      }
    }

    response.status(status).json({
      success: false,
      statusCode: status,
      message,
      timestamp: new Date().toISOString(),
      path: request.url,
    });
  }
}

@catch = Captura cualquier excepcion
@catch(HttpException) = Captura solo errores HTTP.
ArgumentHost = Es una bastraccion que permite acceder al request/response independientemente del protocolo (HTTP, WebSocket, microservicios)

Luego registrarlo globalmente en el main.ts. importando el mismo archivo creado y registrándolo de manera global.

...
import { AllExceptionsFilter } from './filters/http-exception.filter';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  // Exception Filter global
  app.useGlobalFilters(new AllExceptionsFilter());

...
}

Aunque existen niveles de aplicación como a un método o a un controlador (todos los endpoints) con @UseFilters() y toda la aplicación con app.useGlobalFilters()

Antes el error genérico era algo como:

{ "statusCode": 500, "message": "Internal server error" }

Ahora seria algo asi

{
  "success": false,
  "statusCode": 409,
  "message": "Ya existe un registro con ese email",
  "timestamp": "2026-06-19T03:00:00.000Z",
  "path": "/docente"
}

Eso seria, podemos gestionar diferentes errores de manera centralizada.

¡Saludos!

Extendiendo el proyecto de Usuario: Enlace

Podemos incluirle el Swagger para documentar la API.

instalar

npm install @nestjs/swagger

Es asi que al archivo de main.ts le voy a incluir o habilitar Swagger, hay que importar en el main y agregar las siguientes lineas

import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';

// Swagger
  const config = new DocumentBuilder()
      .setTitle('Sistema de Usuario API')
      .setDescription('API para gestion de usuarios')
      .setVersion('1.0')
      .addTag('usuario')
      .build();

  const document = SwaggerModule.createDocument(app, config);
  SwaggerModule.setup('api', app, document);

Quedando el archivo main.ts de la siguiente manera.

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { ValidationPipe } from '@nestjs/common'; // Validator
import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  app.useGlobalPipes(new ValidationPipe({
    whitelist: true, // Elimina los campos que no estan en los DTOs
    forbidNonWhitelisted: true, // Lanza un error si llegan campos extra
    transform: true,  // Transforma tipos automaticamente.
  }));

  // Swagger
  const config = new DocumentBuilder()
      .setTitle('Sistema de Usuario API')
      .setDescription('API para gestion de usuarios')
      .setVersion('1.0')
      .addTag('usuario')
      .build();

  const document = SwaggerModule.createDocument(app, config);
  SwaggerModule.setup('api', app, document);

  await app.listen(process.env.PORT ?? 3000);
}
bootstrap();

Luego hay que decorar los DTOs, importando el ApiProperty y utilizar el decorador en cada campo con la estructura de datos con example y description.

import { IsEmail, IsNotEmpty, IsString, IsNumber, Min, Max } from 'class-validator';
import { Type } from 'class-transformer';
import { ApiProperty } from '@nestjs/swagger';

export class CreateUsuarioDto {

    @ApiProperty({ example: 'Jefferson', description: 'Nombre del usuario'})
    @IsNotEmpty({message: 'El nombre es obligatorio'})
    @IsString()
    nombre!: string;

    @ApiProperty({ example: 'jeffsp@gmail.com', description: 'Correo del usuario'})
    @IsNotEmpty()
    @IsEmail({}, {message: 'Email inválido'})
    email!: string;

    @ApiProperty({ example: '30', description: 'Edad del usuario'})
    @IsNumber()
    @Min(18, {message: 'Debe de ser mayor de 18'})
    @Max(99)
    @Type( () => Number) //Aqui se utiliza la clase transform explicitamente.
    edad!: number;
}

Finalmente, mejorar el controlador con: ApiTags, ApiOperation y ApiResponse

import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
import { UsuarioService } from './usuario.service';
import { CreateUsuarioDto } from './dto/create-usuario.dto';
import { UpdateUsuarioDto } from './dto/update-usuario.dto';
import { ApiTags, ApiOperation, ApiResponse } from '@nestjs/swagger';

@ApiTags('usuario')
@Controller('usuario')
export class UsuarioController {
  constructor(private readonly usuarioService: UsuarioService) {}

  @ApiOperation({summary:'Crear nuevo usuario'})
  @ApiResponse({status:201, description:'Usuario creado'})
  @ApiResponse({status:400, description:'Datos inválidos'})
  @Post()
  create(@Body() createUsuarioDto: CreateUsuarioDto) {
    return this.usuarioService.create(createUsuarioDto);
  }

  @ApiOperation({summary: 'Listar todos los usuarios'})
  @ApiResponse({status:200, description:'Lista de usuarios'})
  @Get()
  findAll() {
    return this.usuarioService.findAll();
  }

  @ApiOperation({summary: 'Obtener usuario por ID'})
  @ApiResponse({status:200, description: 'Usuario encontrado'})
  @ApiResponse({status:404, description: 'Usuario no encontrado'})
  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.usuarioService.findOne(+id);
  }

  @ApiOperation({summary: 'Actualizar usuario'})
  @ApiResponse({status: 200, description: 'Usuario actualizado'})
  @Patch(':id')
  update(@Param('id') id: string, @Body() updateUsuarioDto: UpdateUsuarioDto) {
    return this.usuarioService.update(+id, updateUsuarioDto);
  }

  @ApiOperation({summary: 'Eliminar usuario'})
  @ApiResponse({status: 200, description: 'Usuario Eliminado'})
  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.usuarioService.remove(+id);
  }
}

Descripción de decoradores:

• @ApiTags(‘usuario’) = Agrupa endpoints bajo una sección en la UI
• @ApiProperty() = Documenta cada campo del DTO con ejemplo
• @ApiOperation() = Describe qué hace el endpoint
• @ApiResponse() = Documenta los posibles códigos de respuesta

Ello seria suficiente para tener una API documentada.

Una vez configurado, accede a http://localhost:3000/api para ver la documentación interactiva.

¡Saludos!

Descripción

class-transform

Se encarga de cambiar al tipo correcto de dato.

En el servicio no se ven por que hacen su trabajo antes de que llegue el request ahí. El servicio recibe los datos ya validados y transformados.

Donde actúan los transformers en el Param(‘id’) del controlador.

// Sin transform: true
@Get(':id')
findOne(@Param('id') id: string) {  // id llega como STRING "1"
  return this.usuarioService.findOne(+id); // necesitas el +id para convertir
}

// Con transform: true puedes hacer esto:
@Get(':id')
findOne(@Param('id', ParseIntPipe) id: number) { // id ya llega como NUMBER
  return this.usuarioService.findOne(id); // sin el +
}

El @body tambien convierte los tipos automaticamente

// Si el DTO tiene edad: number
// y el cliente manda: { "edad": "25" }  ← string
// transform: true lo convierte a número automáticamente antes de llegar al servicio

Se coloco un transform explicito dentro del DTO create (CreateUsuarioDto)

@Type(() => Number)

class-validator

Valida que los datos sean los correctos.

ValidationPipe

Se encarga de orquestar ambos.

Vamos a utilizar el validator y transformers.

Lo primero hay que instalar las dependencias.

npm install class-validator class-transformer

voy a modificar el archivo principal main.ts importante los ValidationPipe y agregando unas lineas para su uso.

import { ValidationPipe } from '@nestjs/common'; // Validator

  app.useGlobalPipes(new ValidationPipe({
    whitelist: true, // Elimina los campos que no estan en los DTOs
    forbidNonWhitelisted: true, // Lanza un error si llegan campos extra
    transform: true,  // Transforma tipos automaticamente.
  }));

Sin whitelist considera que el campo extra llega al servicio
Con whitelist: true considera que campo extra se elimina silenciosamente
Con forbidNonWhitelisted: true >> lanza error 400

Quedando de esta manera.

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { ValidationPipe } from '@nestjs/common'; // Validator

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  app.useGlobalPipes(new ValidationPipe({
    whitelist: true, // Elimina los campos que no estan en los DTOs
    forbidNonWhitelisted: true, // Lanza un error si llegan campos extra
    transform: true,  // Transforma tipos automaticamente.
  }));

  await app.listen(process.env.PORT ?? 3000);
}
bootstrap();

He generado una entidad llamada Usuario para poder hacer las validaciones.

nest g resource Usuario

Entonces vamos a utilizar arrays en memoria dado que no me he conectado a una base de datos prisma.

// Usaremos arrays en memoria, dado que no conecte a prisma
export class Usuario {
    id!: number;
    nombre!: string;
    email!: string;
    edad!: number;
}

DTOs (Simple sin validaciones)

export class CreateUsuarioDto {
    nombre!: string;
    email!: string;
    edad!: number;    
}

Ahora le voy a incluir las validaciones en una primera version.

import { IsEmail, IsNotEmpty, IsString, IsNumber, Min, Max } from 'class-validator';
import { Type } from 'class-transformer';

export class CreateUsuarioDto {

    @IsNotEmpty({message: 'El nombre es obligatorio'})
    @IsString()
    nombre!: string;

    @IsNotEmpty()
    @IsEmail({}, {message: 'Email inválido'})
    email!: string;

    @IsNumber()
    @Min(18, {message: 'Debe de ser mayor de 18'})
    @Max(99)
    @Type( () => Number) //Aqui se utiliza la clase transform explicitamente.
    edad!: number;
}

import { PartialType } from '@nestjs/mapped-types';
import { CreateUsuarioDto } from './create-usuario.dto';

export class UpdateUsuarioDto extends PartialType(CreateUsuarioDto) {}

Se define el servicio.

import { Injectable, NotFoundException } from '@nestjs/common';
import { CreateUsuarioDto } from './dto/create-usuario.dto';
import { UpdateUsuarioDto } from './dto/update-usuario.dto';
import { Usuario } from './entities/usuario.entity'; // Importar entity

@Injectable()
export class UsuarioService {

  // Array en memoria como una base de datos temporal
  private usuarios: Usuario[] = []
  private idCounter = 1;

  create(data: CreateUsuarioDto): Usuario {
    const usuario: Usuario = {
      id: this.idCounter++,
      ...data,
    };
    this.usuarios.push(usuario);
    return usuario;
  }

  findAll(): Usuario[] {
    return this.usuarios;
  }

  findOne(id: number): Usuario {
    const usuario = this.usuarios.find(u => u.id === id);
    if (!usuario) throw new NotFoundException(`Usuario ${id} no encontrado`);
    return usuario;
  }

  update(id: number, data: UpdateUsuarioDto): Usuario {
    const usuario = this.findOne(id);
    Object.assign(usuario, data) // Actualiza solo los campos enviados
    return usuario;
  }

  remove(id: number): {message: string} {
    const index = this.usuarios.findIndex(u => u.id ===id);
    if (index === -1) throw new NotFoundException(`Usuario ${id} no encontrado`);
    this.usuarios.splice(index, 1);
    return {message: `Usuario ${id} eliminado`};
  }
  
}

En el controlador y el modulo, no hay mayor cambio.

Formas de validar la operaciones CRUD de Usuario.

# Crear
Invoke-WebRequest -Uri http://localhost:3000/usuario -Method POST -Headers @{"Content-Type"="application/json"} -Body '{"nombre":"Jeff","email":"jeff@gmail.com","edad":25}' | Select-Object -ExpandProperty Content

# Listar
Invoke-WebRequest -Uri http://localhost:3000/usuario -Method GET | Select-Object -ExpandProperty Content | ConvertFrom-Json

# Actualizar
Invoke-WebRequest -Uri http://localhost:3000/usuario/1 -Method PATCH -Headers @{"Content-Type"="application/json"} -Body '{"nombre":"Jeff Santillan"}' | Select-Object -ExpandProperty Content

# Eliminar
Invoke-WebRequest -Uri http://localhost:3000/usuario/1 -Method DELETE | Select-Object -ExpandProperty Content

Validaciones

Error por ingreso de edad superior a 99

Mensaje de error por que no se ingreso un nombre:

Mensaje de error por un email no valido.

Se logra la validación de manera exitosa.

{
  "id": 1,
  "nombre": "Jeff",
  "email": "jeff@gmail.com",
  "edad": 25
}

¡Saludos!

Vamos a empezar definiendo la funcionalidad para curso.

CURSO:

Entity:

export class Curso {
    id!: number;
    nombre!: string;
    codigo!: string;
    creditos!: number;
    docenteId!: number;
}

DTOs, create y update:

export class CreateCursoDto {
    nombre!: string;
    codigo!: string;
    creditos!: number;
    docenteId!: number;
}

import { PartialType } from '@nestjs/mapped-types';
import { CreateCursoDto } from './create-curso.dto';

export class UpdateCursoDto extends PartialType(CreateCursoDto) {}

Services

import { Injectable, NotFoundException } from '@nestjs/common';
import { CreateCursoDto } from './dto/create-curso.dto';
import { UpdateCursoDto } from './dto/update-curso.dto';
import { PrismaService } from '../prisma/prisma.service';

@Injectable()
export class CursoService {

  constructor(private prisma: PrismaService){}

  async create(data: CreateCursoDto) {    
    // Necesario es verificar que el docente exista antes de crear un curso.
    const docente = await this.prisma.docente.findUnique({
      where: { id: data.docenteId},
    });
    if(!docente) throw new NotFoundException(`Docente ${data.docenteId} no encontrado`);
    return this.prisma.curso.create({data});
  }

  findAll() {
    return this.prisma.curso.findMany({
      include: {
        docente: true, //Muestra al docente.
      }
    });
  }

  async findOne(id: number) {
    const curso = await this.prisma.curso.findUnique({
      where: {id},
      include: { docente: true}
    });
    if(!curso) throw new NotFoundException(`Curso ${id} no encontrado`);
    return curso;
  }

  async update(id: number, data: UpdateCursoDto) {
    await this.findOne(id);
    return this.prisma.curso.update({ where: {id}, data });
  }

  async remove(id: number) {
    await this.findOne(id);
    return this.prisma.curso.delete({ where: {id} });
  }
}

Hay validaciones importantes como la existencia previa de un docente antes de crear el curso.

Controller

import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
import { CursoService } from './curso.service';
import { CreateCursoDto } from './dto/create-curso.dto';
import { UpdateCursoDto } from './dto/update-curso.dto';

@Controller('curso')
export class CursoController {
  constructor(private readonly cursoService: CursoService) {}

  @Post()
  create(@Body() body: CreateCursoDto) {
    return this.cursoService.create(body);
  }

  @Get()
  findAll() {
    return this.cursoService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.cursoService.findOne(+id);
  }

  @Patch(':id')
  update(@Param('id') id: string, @Body() body: UpdateCursoDto) {
    return this.cursoService.update(+id, body);
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.cursoService.remove(+id);
  }
}

Module

import { Module } from '@nestjs/common';
import { CursoService } from './curso.service';
import { CursoController } from './curso.controller';

@Module({
  controllers: [CursoController],
  providers: [CursoService],
})
export class CursoModule {}

MATRICULA:

Para concluir

Entity:

export class Matricula {
    id!: number;
    alumnoId!: number; //FK de alumno
    cursoId!: number; //FK de curso
    fecha!: Date;
    estado!: string;
}

Aqui estamos declarando las foreign keys o las llaves que relacionan con otra tabla.

DTOs, create y update:

export class CreateMatriculaDto {
    alumnoId!: number; //FK de alumno
    cursoId!: number; //FK de curso
}

import { PartialType } from '@nestjs/mapped-types';
import { CreateMatriculaDto } from './create-matricula.dto';

export class UpdateMatriculaDto extends PartialType(CreateMatriculaDto) {
    estado!: string; // ACTIVO | RETIRADO | APROBADO
}

Services

import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
import { CreateMatriculaDto } from './dto/create-matricula.dto';
import { UpdateMatriculaDto } from './dto/update-matricula.dto';
import { PrismaService } from '../prisma/prisma.service';

@Injectable()
export class MatriculaService {

  constructor(private prisma: PrismaService){};

  async create(data: CreateMatriculaDto) {
    // Verificar que el alumno existe
    const alumno = await this.prisma.alumno.findUnique({
      where: { id: data.alumnoId }
    });
    if(!alumno) throw new NotFoundException(`Alumno ${data.alumnoId} no encontrado`);

    // Verificar que un curso existe
    const curso = await this.prisma.curso.findUnique({
      where: { id: data.cursoId }
    });
    if(!curso) throw new NotFoundException(`Curso ${data.cursoId} no encontrado`);

    // Verificar que no esta matriculado
    const existe = await this.prisma.matricula.findUnique({
      where: {
        alumnoId_cursoId: {
          alumnoId: data.alumnoId,
          cursoId: data.cursoId
        }
      }
    });
    if (existe) throw new BadRequestException('El alumno ya está matriculado en este curso');

    return this.prisma.matricula.create({
      data, 
      include: {
        alumno: true,
        curso: { include: {docente: true} }
      }
    });

  }

  findAll() {
    return this.prisma.matricula.findMany({
      include: {
        alumno: true,
        curso: { include: { docente: true }} // Curso con su correspondiente docente.
      }
    })
  }

  async findOne(id: number) {
    const matricula = await this.prisma.matricula.findUnique({
      where: {id},
      include: {
        alumno: true,
        curso: { include: { docente: true}}
      }
    });
    if (!matricula) throw new NotFoundException(`Matricula ${id} no encontrada`);
    return matricula;
  }

  async update(id: number, data: UpdateMatriculaDto) {
    await this.findOne(id);
    return this.prisma.matricula.update({ where: {id}, data})
  }

  async remove(id: number) {
    await this.findOne(id) ;
    return this.prisma.matricula.delete({ where : {id} });
  }

  // Curso de un alumno especifico
  findByAlumno(alumnoId: number){
    return this.prisma.matricula.findMany({
      where: { alumnoId },
      include: {
        curso: { include : {docente: true}}
      }
    });
  }

}

Controller

import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
import { MatriculaService } from './matricula.service';
import { CreateMatriculaDto } from './dto/create-matricula.dto';
import { UpdateMatriculaDto } from './dto/update-matricula.dto';

@Controller('matricula')
export class MatriculaController {
  constructor(private readonly matriculaService: MatriculaService) {}

  @Post()
  create(@Body() body: CreateMatriculaDto) {
    return this.matriculaService.create(body);
  }

  @Get()
  findAll() {
    return this.matriculaService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.matriculaService.findOne(+id);
  }

  @Patch(':id')
  update(@Param('id') id: string, @Body() body: UpdateMatriculaDto) {
    return this.matriculaService.update(+id, body);
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.matriculaService.remove(+id);
  }

  // Curso de un alumno especifico
  @Get('alumno/:alumnoId')
  findByAlumno(@Param('alumnoId') alumnoId: string){
    return this.matriculaService.findByAlumno(+alumnoId);
  }

}

Module

import { Module } from '@nestjs/common';
import { MatriculaService } from './matricula.service';
import { MatriculaController } from './matricula.controller';

@Module({
  controllers: [MatriculaController],
  providers: [MatriculaService],
})
export class MatriculaModule {}

Con esto concluimos el registro de matricula de un alumno dentro de un curso.

Operaciones para Curso

Crear un curso con el docente con ID 1

Invoke-WebRequest -Uri http://localhost:3000/curso -Method POST -Headers @{"Content-Type"="application/json"} -Body '{"nombre":"Matematicas","codigo":"MAT101","creditos":4,"docenteId":1}' | Select-Object -ExpandProperty Content

Invoke-WebRequest -Uri http://localhost:3000/curso -Method POST -Headers @{"Content-Type"="application/json"} -Body '{"nombre":"Programacion","codigo":"PRG101","creditos":5,"docenteId":1}' | Select-Object -ExpandProperty Content

Listar cursos

Invoke-WebRequest -Uri http://localhost:3000/curso -Method GET -UseBasicParsing | Select-Object -ExpandProperty Content | ConvertFrom-Json

Obtener curso por ID

Invoke-WebRequest -Uri http://localhost:3000/curso/1 -Method GET | Select-Object -ExpandProperty Content | ConvertFrom-Json

Actualizar curso

Invoke-WebRequest -Uri http://localhost:3000/curso/1 -Method PATCH -Headers @{"Content-Type"="application/json"} -Body '{"nombre":"Matematica Avanzada"}' | Select-Object -ExpandProperty Content

Eliminar

Invoke-WebRequest -Uri http://localhost:3000/curso/1 -Method DELETE | Select-Object -ExpandProperty Content

Todas las operaciones ya estan disponibles para el curso.

Operaciones para Matricula

Matricular alumno a un curso.

Invoke-WebRequest -Uri http://localhost:3000/matricula -Method POST -Headers @{"Content-Type"="application/json"} -Body '{"alumnoId":1,"cursoId":1}' -UseBasicParsing | Select-Object -ExpandProperty Content

Ver todas las matriculas

Invoke-WebRequest -Uri http://localhost:3000/matricula -Method GET -UseBasicParsing | Select-Object -ExpandProperty Content | ConvertFrom-Json

Curso de un alumno en especifico.

Invoke-WebRequest -Uri http://localhost:3000/matricula/alumno/1 -Method GET -UseBasicParsing | Select-Object -ExpandProperty Content | ConvertFrom-Json

¡Saludos!

Lo que haremos es instalar una versión más reciente de forma paralela, pudiendo así alternar entre versiones: una estable que usa el sistema por defecto y otra más moderna para pruebas.

Versión actual

python3 --version

Asi que vamos a instalar una versión nueva en paralelo, haciendo uso del PPA de deadsnakes.

# Agregar el repositorio

sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt-get update

# Instalar la versión que quieras (ejemplo: 3.12 o 3.13)

sudo apt-get install python3.14

Verificar la versión

python3.14 --version

Vamos a realizar que python3 apunte a la version mas reciente.

# Ver las versiones instaladas.

ls /usr/bin/python3*

# Configurar alternativas

sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.14 1

# Elegir cual utilizar

sudo update-alternatives --config python3 

Finalmente, hacer que python funcione sin el 3 (python3)

sudo apt-get install python-is-python3

Considera, que Ubuntu internamente rutas absolutas como /usr/bin/python3.13 para sus herramientas criticas, no el symlink genérico.

update-alternatives solo cambia el symlink, no afecta, elimina o reemplaza el python 3.13

¿Problemas con el pip?

Es posible que python-apt sigue apuntando a 3.13 sera mejor reinstalar.

sudo apt-get install --reinstall python3-apt

Además, instalar pip para Python 3.14

sudo apt-get install python3-pip

Validar y verificar las versiones

python3 --version
pip3 --version
pip3 list

Saludos

Python: Enlace

Modo con SNAP.

sudo snap install code --classic

Para desinstalar

sudo snap remove code

Es requerido el flag de classic, dado que la instalacion necesita de acceso al sistema de archivos.

Alternativa con firma de Microsoft.

Sera necesario ejecutar el proximo script.

# Agregar la clave GPG de Microsoft

curl -fsSL https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor | sudo tee /usr/share/keyrings/microsoft.gpg > /dev/null

# Agregar el repo de VSCode

echo "deb [arch=amd64 signed-by=/usr/share/keyrings/microsoft.gpg] https://packages.microsoft.com/repos/code stable main" | sudo tee /etc/apt/sources.list.d/vscode.list

# Actualizar e Instalar

sudo apt-get update
sudo apt-get install code

Si deseas ejecutar el programa VSCode desde la terminal solo digita

code .

Luego ir a la seccion de extensiones con CTRL + SHIFT + X

y buscar Claude de Anthropic

Dar clic en Install con el Auto Update marcado.

Finalmente. Tendra un icono con el Claude, listo para iniciar sesión.

Es necesario autentica con Claude.ai

¡Saludos!

Para realizar la instalación de Claude Code en Linux Ubuntu es necesario que previamente tengas instalado el curl.

Instalar Curl

sudo apt-get install curl

Instalación de Claude Code

curl -fsSL https://claude.ai/install.sh | bash

Si logra la instalación.

como indica el resultado, el programa Claude se ubica en

~/local/bin/claude

Solicitar conocer la version del programa

~/local/bin/claude --version

Luego el certificado tendrá un costo de $99 y será de 60 preguntas, supervisado y tiene una duración de 120 minutos como máximo, con un solo intento, es un examen de nivel 301.

Tienes que demostrar la experiencia en la creación de aplicaciones de nivel profesional en Claude.

De momento, solo nos proporciona una guia de estudio para aquellas personas que no aplican al certificado por no tener un correo de socios de Anthropic de forma anticipada. Ve dandote una idea con la Guía de Estudio

Incluso si aún no formas parte de sus socios, tampoco podrias acceder al examen de simulación por ahora. Examen de simulación, te recomiendan lograr 900 de 1000 para recien poder rendir el examen oficial.

Dominios de evaluación

• Arquitectura y orquestación de agentes (27%)
• Diseño de herramientas e integración de MCP (18%)
• Configuración de código y flujos de trabajo en Claude (20%)
• Ingenieria rápida y resultados estructurados (20%)
• Gestión del Contexto y la fiabilidad (15%)

Sugieren que lleves previamente los cursos de:

• Claude 101
• Claude Code en acción
• Introducción al Protocolo de Contexto
• Compilación con la API de Claude.

Revisa los cursos disponibles en la academia antrópica.

Descubre más en su web por su enlace principal.

Start Building with Claude – Here

Anthropic Academy

La empresa ha lanzado un conjunto de cursos, desde guías de desarrollo de API hasta las mejores practicas de implementación empresarial, la academia Antrópica está ofreciendo todo lo que necesitas.

https://www.anthropic.com/learn

01 – Claude 101

Aprender a usar Claude para tareas laborales cotidianas, comprende sus funciones principales y explora recursos para un aprendizaje más avanzado sobre otros temas.

Duración: 14 lecciones

https://anthropic.skilljar.com/claude-101

02 – Claude Code en Acción

Integra Claude Code en tu flujo de trabajo de desarrollo

Duración: 21 lecciones.

https://anthropic.skilljar.com/claude-code-in-action

03 – Introducción a las habilidades de agente

Aprende a crear, configurar y compartir habilidades (Skills) en Claude Code:

Instrucciones Markdown reutilizables que Claude aplica automáticamente a las tareas adecuadas en el momento preciso. El curso te guía desde la creación de la primera Skill hasta la distribución entre equipos y la resolución de problemas comunes.

https://anthropic.skilljar.com/introduction-to-agent-skills

04 – Competencia con IA: Marco y Fundamentos

Aprende a colaborar con sistemas de IA de forma eficaz, eficiente, ética y segura.

Duración: 1.1 Hrs

https://anthropic.skilljar.com/ai-fluency-framework-foundations

05 – Construyendo con API de Claude

Este curso integral abarca todo el espectro del trabajo con modelos antrópicos utilizando la API de Claude.

Duración: 8.1 Hrs

http://anthropic.skilljar.com/claude-with-the-anthropic-api

06 – Introducción al Protocolo de Contexto de Modelo (MCP)

Aprende a crear servidores y clientes del Protocolo de Contexto de Modelo (MCP) desde cero usando Python. Domina las tres primitivas principales de MCP (Herramientas, recursos y mensajes) para conectar Claude con servicios externos.

Duración: 1 Hrs

https://anthropic.skilljar.com/introduction-to-model-context-protocol

07 – Protocolo de Contexto del Modelo: Temas avanzados

Descubra patrones avanzados de implementación del MCP que incluye muestreo, notificaciones, acceso al sistema de archivos y mecanismos de transporte para el desarrollo de servidores MCP en producción.

Duración: 1.1 Hrs

https://anthropic.skilljar.com/model-context-protocol-advanced-topics

08 – Claude con Google Cloud’s Vertex AI

El curso abarca el uso de modelos Claude a través de la plataforma Vertex AI de Google Cloud. En donde se implementará funciones clave de la API, como la transmisión de datos y el uso de herramientas, en donde se creará flujos de trabajo sistemáticos para la evaluación de indicadores, comprenderás los sistemas RAG y se investigara las arquitecturas de los agentes.

Duración: 8 Hrs

https://anthropic.skilljar.com/claude-with-google-vertex

09 – Claude con Amazon Bedrock

Abarca el uso de modelos Claude a través de la API de AWS Bedrock, desde solicitudes básicas hasta implementaciones avanzadas de agentes. Aprendes a realizar la llamada a la API, implementar el uso de herramientas, crear canalizaciones RAG, trabajar con servidores MCP y aprovechar funciones como Claude Code y el uso de computadoras para la automatización.

Duración: 8 Hrs

https://anthropic.skilljar.com/claude-in-amazon-bedrock

10 – Alfabetización en IA para educadores.

El curso capacita a profesores, diseñadores instruccionales y lideres educativos para aplicar fluidez en la IA a su propia práctica docente y estrategia institucional.

Duración: 0.4 Hrs

https://anthropic.skilljar.com/ai-fluency-for-educators

11 – Enseñar fluides en IA

Curso de capacitación al profesorado, a los diseñadores de instrucciones y a otros profesionales para enseñar a evaluar la competencia de la IA en entornos dirigidos por un instructor.

Duración: 0.6 Hrs

https://anthropic.skilljar.com/teaching-ai-fluency

12 – Alfabetización en IA para estudiantes

El curso capacita a estudiantes para desarrollar habilidades de dominio en IA que mejoran el aprendizaje, la planificación profesional y el éxito académico a través de una colaboración responsable de la IA.

Duración: 0.5 Hrs

https://anthropic.skilljar.com/ai-fluency-for-students

13 – IA para organizaciones sin fines de lucro

Curso desarrollado para organizaciones sin fines de lucro para el desarrollo de habilidades en IA con el fin de aumentar el impacto y eficiencia de sus organizaciones, sin dejar de ser fieles a su misión y valores.

Duración: 0.9 Hr

https://anthropic.skilljar.com/ai-fluency-for-nonprofits

Puedes acceder a todos los cursos de Anthropic desde el siguiente enlace:

https://anthropic.skilljar.com

Mas información en el blog del proyecto. Enlace