I create modern web applications and custom digital tools to help businesses grow through technological innovation. My passion is combining computer science and economics to generate real value.
My passion for computer science was born at the Technical Commercial Institute of Maglie, where I discovered the power of programming and the fascination of creating digital solutions. From the start, I understood that computer science was not just code, but an extraordinary tool for turning ideas into reality.
During my studies in Business Information Systems, I began to interweave computer science and economics, understanding how technology can be the engine of growth for any business. This vision accompanied me to the University of Bari, where I obtained my degree in Computer Science, deepening my technical skills and passion for software development.
Today I put this experience at the service of businesses, professionals and startups, creating tailor-made digital solutions that automate processes, optimize resources and open new business opportunities. Because true innovation begins when technology meets the real needs of people.
My Skills
Data Analysis & Predictive Models
I transform data into strategic insights with in-depth analysis and predictive models for informed decisions
Process Automation
I create custom tools that automate repetitive operations and free up time for value-added activities
Custom Systems
I develop tailor-made software systems, from platform integrations to customized dashboards
Credo fermamente che l'informatica sia lo strumento più potente per trasformare le idee in realtà e migliorare la vita delle persone.
Democratizzare la Tecnologia
La mia missione è rendere l'informatica accessibile a tutti: dalle piccole imprese locali alle startup innovative, fino ai professionisti che vogliono digitalizzare la propria attività. Ogni realtà merita di sfruttare le potenzialità del digitale.
Unire Informatica ed Economia
Non è solo questione di scrivere codice: è capire come la tecnologia possa generare valore reale. Intrecciando competenze informatiche e visione economica, aiuto le attività a crescere, ottimizzare processi e raggiungere nuovi traguardi di efficienza e redditività.
Creare Soluzioni su Misura
Ogni attività è unica, e così devono esserlo le soluzioni. Sviluppo strumenti personalizzati che rispondono alle esigenze specifiche di ciascun cliente, automatizzando processi ripetitivi e liberando tempo per ciò che conta davvero: far crescere il business.
Trasforma la Tua Attività con la Tecnologia
Che tu gestisca un negozio, uno studio professionale o un'azienda, posso aiutarti a sfruttare le potenzialità dell'informatica per lavorare meglio, più velocemente e in modo più intelligente.
Bari, Puglia, Italy · Hybrid
Analysis and development of computer systems through the use of Java and Quarkus in Health and Public Sector. Continuous training on modern technologies for creating customized and efficient software solutions and on agents.
💼
06/2022 - 12/2024
Software analyst and Back End Developer Associate Consultant
Links Management and Technology SpA
Experience analyzing as-is software systems and ETL flows using PowerCenter. Completed Spring Boot training for developing modern and scalable backend applications. Backend developer specialized in Spring Boot, with experience in database design, analysis, development and testing of assigned tasks.
💼
02/2021 - 10/2021
Software programmer
Adesso.it (prima era WebScience srl)
Experience in AS-IS and TO-BE analysis, SEO evolutions and website evolutions to improve user performance and engagement.
🎓
2018 - 2025
Degree in Computer Science
University of Bari Aldo Moro
Bachelor's degree in Computer Science, focusing on software engineering, algorithms, and modern development practices.
📚
2013 - 2018
Diploma - Corporate Information Systems
Technical Commercial Institute of Maglie
Technical diploma specializing in Business Information Systems, combining IT knowledge with business management.
Contattami
Hai un progetto in mente? Parliamone! Compila il form qui sotto e ti risponderò al più presto.
* Campi obbligatori. I tuoi dati saranno utilizzati solo per rispondere alla tua richiesta.
Introduction: The Complete Journey
This is the final article in the series dedicated to the Model Context Protocol (MCP).
Across 14 articles, we have traveled a complete path: from the theoretical foundations of the protocol
to implementing a production-ready ecosystem with 31 MCP servers, 85+ tools, 6 shared packages,
and a professional testing system.
In this article, we present a complete overview of the open source project
Tech-MCP:
the catalog of all servers organized by category, the technology stack, the overall architecture,
lessons learned during development, and how to contribute to the project.
What You Will Learn in This Article
Complete overview of the Tech-MCP project with numbers and statistics
The Tech-MCP project
is the result of a design and development process that produced a complete MCP ecosystem,
covering the entire software development lifecycle. Here are the key numbers:
Project Statistics
Metric
Value
MCP Servers
31
Available Tools
85+
Shared Packages
6
Typed Events
29
Lines of TypeScript Code
23,000+
Language
TypeScript 5.7
Runtime
Node.js 20+
Build System
Turborepo + pnpm
Database
SQLite (better-sqlite3)
Validation
Zod
Testing
Vitest
License
Open Source
Overall Architecture
Tech-MCP is organized as a monorepo managed with pnpm workspaces and Turborepo.
Shared packages provide cross-cutting functionality, while the 31 servers implement
domain-specific business logic:
The 31 MCP servers are organized into 9 functional categories covering every aspect of the
software development lifecycle. Each server is independent but can collaborate with others
via EventBus and ClientManager.
Project Management (5 servers)
Server
Key Tools
Description
scrum-board
create-sprint, add-story, update-task-status
Sprint, story, and task management with complete Scrum board
agile-metrics
calculate-velocity, get-burndown, cycle-time
Agile metrics: velocity, burndown, lead time, cycle time
time-tracking
start-timer, stop-timer, get-timesheet
Time tracking with timers and weekly reports
project-economics
set-budget, log-expense, get-budget-status
Budget management, expenses, and project economic analysis
retrospective-manager
create-retro, add-feedback, generate-actions
Sprint retrospectives with feedback and corrective actions
Productivity (3 servers)
Server
Key Tools
Description
code-review
analyze-diff, find-issues, suggest-improvements
Code analysis with issue identification and improvements
dependency-manager
scan-dependencies, check-updates, audit-security
Dependency management, updates, and security auditing
project-scaffolding
generate-project, add-module, create-config
Project structure generation and module scaffolding
Database schema exploration with relationship analysis
data-mock-generator
generate-mock-data, create-fixture, seed-database
Realistic test data and fixture generation
Testing (2 servers)
Server
Key Tools
Description
test-generator
generate-unit-tests, generate-integration-tests
Automatic generation of unit and integration tests
performance-profiler
profile-endpoint, find-bottlenecks, benchmark
Performance profiling and bottleneck identification
Documentation (2 servers)
Server
Key Tools
Description
api-documentation
generate-docs, validate-openapi, create-examples
API documentation generation and OpenAPI validation
codebase-knowledge
index-codebase, search-code, explain-module
Codebase knowledge base with semantic search
Utility (3 servers)
Server
Key Tools
Description
regex-builder
build-regex, test-pattern, explain-regex
Regular expression building and testing
http-client
send-request, test-endpoint, mock-api
HTTP client for API testing and endpoint mocking
snippet-manager
save-snippet, search-snippets, get-snippet
Code snippet management with tags and search
Communication (2 servers)
Server
Key Tools
Description
standup-notes
create-standup, list-standups, generate-summary
Daily standup management with notes and summaries
environment-manager
list-environments, compare-configs, sync-env
Deployment environment and configuration management
Advanced (9 servers)
Server
Key Tools
Description
incident-manager
create-incident, update-status, post-mortem
Incident management with severity levels and post-mortems
decision-log
log-decision, list-decisions, search-context
Architectural Decision Records (ADR) registry
access-policy
define-policy, check-access, audit-permissions
Access policy management and permission auditing
quality-gate
define-gate, evaluate-quality, get-report
Quality gates with configurable metrics and thresholds
workflow-orchestrator
create-workflow, execute-step, get-status
Multi-step workflow orchestration
insight-engine
health-dashboard, cross-project-analysis
Cross-server analysis with data aggregation
mcp-registry
register-server, list-servers, discover-tools
MCP server registry with automatic discovery
dashboard-api
create-dashboard, add-widget, get-metrics
Dashboard API for metrics visualization
tech-radar
add-technology, evaluate-adoption, get-radar
Technology radar for tracking technology adoption
Technology Stack
Tech-MCP's technology stack was chosen to maximize type-safety, development speed,
and long-term maintainability:
Technologies Used
Component
Technology
Role
Language
TypeScript 5.7
Type-safety, interfaces, generics
Runtime
Node.js 20+
Native ES modules, performance
Package Manager
pnpm 9+
Monorepo workspace, efficient linking
Build System
Turborepo
Parallel builds, caching, task orchestration
Database
SQLite (better-sqlite3)
Local persistence, zero configuration
Validation
Zod
Schema validation, type inference
MCP SDK
@modelcontextprotocol/sdk
Official MCP protocol
Testing
Vitest
Unit tests, integration tests, mocking
Transport
STDIO + Streamable HTTP
Local and remote communication
The 6 Shared Packages
The shared packages provide the foundation upon which all 31 servers are built.
Each package is published internally within the monorepo and consumed by servers via
workspace:*:
Monorepo Packages
Package
Responsibility
Key Exports
@mcp-suite/core
Server factory, shared types, HTTP server
startHttpServer(), common types
@mcp-suite/event-bus
Fire-and-forget typed event system
LocalEventBus, EventMap, 29 events
@mcp-suite/client-manager
Synchronous cross-server communication
McpClientManager, callTool()
@mcp-suite/database
Base SQLite store with migrations
BaseStore, migration utilities
@mcp-suite/testing
Test utilities: harness, mock, transport
createTestHarness(), MockEventBus
@mcp-suite/cli
CLI utility for server management
Commands for start, stop, server status
Key Architectural Patterns
During the development of 31 MCP servers, recurring architectural patterns emerged that
ensure consistency, testability, and maintainability:
1. Server Factory Pattern
Every server exposes a factory function with optional parameters for maximum flexibility:
export function createMyServer(options?: {
eventBus?: EventBus;
clientManager?: McpClientManager;
storeOptions?: { inMemory?: boolean; dbPath?: string };
}) {
const server = new McpServer({
name: "my-server",
version: "1.0.0",
});
const store = new MyStore(options?.storeOptions);
// Register tools with optional dependencies
registerAddItem(server, store, options?.eventBus);
registerGetStats(server, store, options?.clientManager);
// Collaboration: activated only if an event bus is present
if (options?.eventBus) {
setupCollaborationHandlers(options.eventBus, store);
}
return { server, store };
}
2. One File Per Tool
Each tool is isolated in its own file, registered as a pure function that receives its dependencies:
Events are published using the fire-and-forget pattern: the server publishes the event
and continues without waiting for a response. This completely decouples the servers:
// The server publishes without waiting
eventBus?.publish("scrum:sprint-started", {
sprintId: sprint.id,
name: sprint.name,
});
// Another server reacts in its own collaboration.ts
eventBus.subscribe("scrum:sprint-started", (payload) => {
store.autoCreateBudget(payload.sprintId, payload.name);
});
How to Contribute
Tech-MCP is an
open source project and contributions are welcome. The contribution process follows a standard workflow:
Prerequisites
Node.js >= 20.0.0
pnpm >= 9.0.0
Basic knowledge of TypeScript and the Model Context Protocol
Development Environment Setup
# 1. Fork and clone the repository
git clone https://github.com/<your-username>/Tech-MCP.git
cd Tech-MCP
# 2. Install dependencies
pnpm install
# 3. Full build of all packages and servers
pnpm build
# 4. Verify everything compiles correctly
pnpm typecheck
Types of Contributions
Adding a new MCP server: create a new server in the servers/ directory
following the standardized structure (package.json, tsconfig.json, src/index.ts, src/server.ts, src/tools/, src/services/)
Adding a tool to an existing server: create the file in servers/<name>/src/tools/
following the registration pattern with optional dependencies
Adding an event: define the event in packages/event-bus/src/events.ts,
publish in the appropriate tool, and subscribe in the collaboration handler
Implementing collaboration handlers: many collaboration.ts files contain
placeholder handlers with void payload. Implementing the real logic is a valuable contribution
Writing tests: store unit tests, tool integration tests, cross-server wiring tests
Code Conventions
Rules and Conventions
Formatter: Prettier with single quotes, trailing commas, 100 char line width
Tool naming: kebab-case (create-sprint, not createSprint)
Event naming: domain:action-kebab-case
Git branches: feature/feature-name, fix/fix-name
Commits: imperative, concise (e.g., "Add auto-timer to time-tracking")
PRs: one feature/fix per PR, with clear description
Review Process
Fork the repository on GitHub
Create a branch from main
Implement following the project conventions
Build and typecheck: pnpm build && pnpm typecheck
Commit with clear, descriptive messages
Open a Pull Request to main
Respond to review feedback
Areas Where Help Is Needed
The project has several areas where contributions are particularly welcome:
Requested Contributions
Area
Priority
Difficulty
Unit tests for all tools
High
Medium
Redis EventBus implementation
High
Medium
Completing collaboration handlers
Medium
Low
GitHub Actions CI/CD
Medium
Low
Web monitoring dashboard
Low
High
Plugin system
Low
High
Roadmap and Future Developments
Tech-MCP is an evolving project. Planned development areas are organized by priority:
Priority 1: Redis EventBus
Currently the EventBus works only with LocalEventBus (in-process). For real-world
deployments where each server is a separate process, an external message broker is needed.
The Redis implementation will enable inter-process communication between MCP servers
distributed across different machines.
Priority 2: MCP Resources and Prompts
Currently Tech-MCP exclusively uses the Tools primitive. The MCP specification
also defines Resources (read-only data with URIs) and Prompts (templates for structured workflows).
Adding these primitives would significantly enrich server capabilities.
Priority 3: Web Dashboard
A web dashboard for real-time visualization of all server statuses, published events,
tool usage metrics, and health checks.
Priority 4: Plugin System
An architecture for third-party plugins with a registry, tool hot-reload, and a shared marketplace.
Lessons Learned
Building 31 MCP servers in a monorepo taught valuable lessons that apply to any
medium-to-large scale software project:
1. Standardization Pays Off
Having a standardized structure for every server (factory function, one file per tool, isolated store,
separate collaboration handler) drastically reduced the development time for new servers.
After the first 5 servers, creating a new one required very little time because the pattern
was well-established.
2. Shared Packages Are Essential
Extracting common logic into shared packages (core, event-bus, database, testing) eliminated
code duplication and ensured consistency across all servers. Every change to a shared package
automatically propagates to all servers that use it.
3. Tool Descriptions Are Critical
The AI chooses which tool to call based solely on its description. Vague descriptions produce
underutilized tools; precise descriptions produce a smooth experience. Investing time in writing
descriptions is a high-return investment.
4. Fire-and-Forget Simplifies Everything
The fire-and-forget pattern for events enormously simplified the architecture. Servers publish
events without knowing who receives them, and collaboration handlers react without direct coupling.
This made it possible to add new collaborations without modifying existing servers.
5. In-Memory Tests Are Key
The ability to instantiate every server with an in-memory database made tests fast, isolated,
and reproducible. The investment in createTestHarness() and MockEventBus
paid enormous dividends in development speed.
Series Summary
This 14-article series covered the entire journey from the MCP protocol to production.
Here is a summary of the topics covered:
Complete Series Index
#
Topic
Level
01
Introduction to the Model Context Protocol
Beginner
02
MCP Primitives: Tools, Resources, and Prompts
Beginner
03
Monorepo Architecture and Project Patterns
Intermediate
04
Building Your First MCP Server in TypeScript
Intermediate
05
Building an MCP Client and HTTP Transport
Intermediate
06
Shared Packages: Core, EventBus, and Database
Intermediate
07
Productivity Servers
Intermediate
08
DevOps and Database Servers
Intermediate
09
Project Management Servers
Intermediate
10
Advanced Servers: Database and Testing
Advanced
11
Advanced Servers: Orchestration and Registry
Advanced
12
Inter-Server Collaboration and EventBus
Advanced
13
Testing, Best Practices, and Production
Advanced
14
Tech-MCP: Complete Open Source Project Overview
Advanced
Conclusions
The Model Context Protocol represents a paradigm shift in the interaction
between developers and artificial intelligence. It is not simply a wrapper around API calls,
but a structured protocol that enables automatic discovery, strong typing,
bidirectional communication, native composability, and inter-server collaboration.
With Tech-MCP,
we have demonstrated that it is possible to build a complete ecosystem of 31 MCP servers, covering
the entire software development lifecycle: from code management to project management,
from testing to deployment, from monitoring to cross-project analysis.
The project is open source and continuously evolving. Every contribution, whether
it is a new server, a test, a fix, or a new feature, is welcome. The future of human-AI interaction
passes through open and composable protocols like MCP, and Tech-MCP aims to be a reference point
for anyone wanting to explore this territory.
Thank you for following this series. The complete code, documentation, and contribution instructions
are available on
GitHub.