This repository showcases a production-ready enterprise agentic framework - a sophisticated system demonstrating advanced AI agent communication protocols, modern Spring Boot architecture, and professional development practices.

• Native Tools4AI Framework ReWrite: The Complete framework is recreated locally under io.wingie.a2acore.tools4ai.* from https://github.com/vishalmysore/Tools4AI/tree/main/src/main/java/com/t4a/*, while vishalmysores implementation was quite solid, there were some architectural decisions that i woudl have done differently and it wasnt possible to simple use OOP subclassing to get around it, so hence i opted for a rewrite to study more about the A2A and java system as a whole.
• Java 17+ Compatibility: Resolved JAXB and modern Java runtime issues

The startup interface provides a comprehensive view of agent capabilities and real-time interactions:

Interactive resume showcase demonstrating technical expertise:

Real-time AI reasoning and decision-making process visualization:

Advanced meme generation with mood-based template selection:

Automated screenshot capture and processing capabilities:

Comprehensive testing interface for system reliability:

Performance metrics and evaluation of agent capabilities:

Seamless integration with Claude for enhanced AI capabilities:

https://github.com/vishalmysore/Tools4AI/tree/main/src/main/java/com/t4a/transform @vishalmysore for the amazing work on ^, your code was a joy to read

a2awebagent/
├── a2acore/                          # 🎯 LOCAL TOOLS4AI FRAMEWORK
│   └── src/main/java/io/wingie/a2acore/tools4ai/
│       ├── JsonUtils.java            # JSON processing utilities
│       ├── annotations/              # @Prompt, @Action, @Parameter
│       ├── predict/                  # AI prediction capabilities  
│       ├── processor/                # Core processing engine
│       ├── transform/                # Data transformation
│       └── [132 total classes]       # Complete framework recreation
│
└── a2awebapp/                        # APPLICATION USING LOCAL FRAMEWORK
    ├── Application.java              # @EnableA2ACore integration
    ├── PlaywrightProcessor.java      # Web automation interface
    └── [64 application classes]      # Travel research application

// a2awebapp/Application.java
@SpringBootApplication
@EnableA2ACore  // Activates local Tools4AI framework
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

• Location: a2awebagent/ subdirectory
• Structure: Multi-module Maven project with:
  • a2acore/: Fast MCP framework library (replaces heavy a2ajava dependency)
  • a2awebapp/: Spring Boot application with Playwright automation
• Purpose: AI-powered travel research and web automation with locally controlled Tools4AI framework
• Key Features: Travel research automation, flight/hotel search, web browsing with screenshots, PostgreSQL/Redis caching, complete framework recreation

This project serves as:

• A sophisticated travel research agent with comprehensive automation capabilities
• A framework recreation showcase demonstrating advanced dependency management
• A technical achievement demonstration of Tools4AI local integration
• A production-ready MCP protocol implementation for AI-powerlayered agents
• A good base for red teaming attack vectors at architecture example of taking control over external dependencies

The system is built using a modern multi-module Spring Boot architecture with enhanced performance optimization:

• A2aCoreController: Lightweight MCP JSON-RPC endpoint
• ToolDiscoveryService: Auto-discovery of @Action annotated methods
• JsonRpcHandler: Protocol message processing
• Annotations: @EnableA2ACore, @Action, @Parameter
• Performance: Fast-starting replacement for heavy a2ajava library

• Application.java: Spring Boot main class with @EnableA2ACore
• PlaywrightProcessor: Modern web automation interface using Microsoft Playwright
• CachedMCPToolsController: Performance optimization bridge between a2acore and PostgreSQL
• Professional Tools: LinkedIn search, expertise showcase, screenshot utilities
• Caching Services: PostgreSQL + Redis for tool descriptions and performance

• PostgreSQL: Tool description caching and persistent storage
• Redis: High-performance session and data caching
• ToolDescriptionCacheService: Intelligent caching bridge service
• Admin Interfaces:
  • /tools page: Tool descriptions with tabular filtering by model/tool
  • /agents page: Neo4j-logged tool invocations with async job tracking

• getWingstonsProjectsExpertiseResume: Comprehensive technical expertise showcase
• searchLinkedInProfile: Professional profile search and analysis
• browseWebAndReturnText: Intelligent web research and data extraction
• browseWebAndReturnImage: Screenshot capture for visual documentation
• askTasteBeforeYouWaste: Specialized food/restaurant research tool

• Microsoft Playwright: Modern, reliable browser automation (replacing legacy Selenium)
• AI-Powered Error Recovery: Self-healing automation with intelligent retry mechanisms
• Multi-Provider AI Support: OpenAI, Gemini, Claude, Mistral integration
• URL Safety Validation: Built-in security for safe web navigation
• Real-time WebSocket Updates: Live progress tracking and notifications

This project features comprehensive Serena tools integration for professional code analysis:

• Indexed Files: 13 Java source files with Eclipse JDT Language Server
• Symbol Navigation: Fast lookup of classes, methods, and architectural patterns
• Code Analysis: Intelligent understanding of Spring Boot MCP architecture
• Performance: 8.40 files/second indexing with persistent cache

• Architecture Visualization: Component relationships and design patterns
• Code Navigation: Cross-references and call graph analysis
• Documentation: Automated insights for technical communication
• Quality Metrics: Maintainability and complexity analysis

• Java 21+ (configured for modern development)
• Maven 3.8+
• PostgreSQL (for caching and persistence)
• Redis (for high-performance caching)
• Chrome/Chromium (for Playwright automation)

# Navigate to the web agent project
cd a2awebagent

# Build both modules (a2acore + a2awebapp)
mvn clean compile

# Run the professional showcase application
mvn spring-boot:run -pl a2awebapp

# PostgreSQL setup for tool caching
createdb a2aresume

# Redis setup for performance caching
redis-server

For professional demonstration and AI-powered features, configure API keys:

# Professional AI providers
export OPENAI_API_KEY=sk-your-actual-key-here
export CLAUDE_KEY=sk-ant-your-key-here  
export GEMINI_KEY=your-gemini-key-here

# Launch the resume agent
java -jar a2awebapp/target/a2awebapp-0.0.1.jar

Create a2awebagent/a2awebapp/src/main/resources/tools4ai.properties:

##Gemini Configuration (Recommended for resume features)
gemini.modelName=gemini-2.0-flash-001
gemini.location=us-central1
gemini.projectId=your-google-project-id
geminiKey=your-gemini-api-key-here
agent.provider=gemini

##Professional AI Integration
openAiKey=sk-your-openai-key-here
openAiModelName=gpt-4o-mini
claudeKey=sk-ant-your-claude-key-here

##LinkedIn & Web Research
serperKey=your-serper-key-here

For production deployment with all dependencies, use our comprehensive Docker Compose configuration:

# docker-compose.yml
version: '3.8'
services:
  a2awebagent:
    build: .
    ports:
      - "7860:7860"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - DATABASE_URL=jdbc:postgresql://postgres:5432/a2awebagent
      - REDIS_URL=redis://redis:6379
      - NEO4J_URI=bolt://neo4j:7687
      - NEO4J_USERNAME=neo4j
      - NEO4J_PASSWORD=password123
    depends_on:
      - postgres
      - redis
      - neo4j
    volumes:
      - ./screenshots:/app/screenshots
      - ./logs:/app/logs
  
  postgres:
    image: postgres:15
    environment:
      - POSTGRES_DB=a2awebagent
      - POSTGRES_USER=agent
      - POSTGRES_PASSWORD=agent123
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U agent -d a2awebagent"]
      interval: 30s
      timeout: 10s
      retries: 3
  
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    command: redis-server --appendonly yes
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 10s
      retries: 3
  
  neo4j:
    image: neo4j:5
    environment:
      - NEO4J_AUTH=neo4j/password123
      - NEO4J_PLUGINS=["graph-data-science"]
      - NEO4J_dbms_memory_heap_initial__size=512m
      - NEO4J_dbms_memory_heap_max__size=2G
    ports:
      - "7474:7474"
      - "7687:7687"
    volumes:
      - neo4j_data:/data
      - neo4j_logs:/logs
    healthcheck:
      test: ["CMD", "cypher-shell", "-u", "neo4j", "-p", "password123", "RETURN 1"]
      interval: 30s
      timeout: 10s
      retries: 3

volumes:
  postgres_data:
  redis_data:
  neo4j_data:
  neo4j_logs:

# Full stack deployment (recommended)
docker-compose up -d

# Application only (with external DBs)
docker-compose up a2awebagent -d

# Rebuild after code changes
docker-compose down a2awebagent && docker-compose up --build a2awebagent -d

# View real-time logs
docker-compose logs -f a2awebagent

# Health check all services
docker-compose ps

# Database access for debugging
docker exec -it a2a-postgres psql -U agent -d a2awebagent
docker exec -it a2a-redis redis-cli
docker exec -it a2a-neo4j cypher-shell -u neo4j -p password123

# Environment file for production (.env)
OPENAI_API_KEY=sk-your-actual-key-here
CLAUDE_KEY=sk-ant-your-key-here
GEMINI_API_KEY=your-gemini-key-here
SERPER_KEY=your-serper-key-here

# Database configuration
POSTGRES_PASSWORD=your-secure-password-here
REDIS_PASSWORD=your-redis-password-here
NEO4J_PASSWORD=your-neo4j-password-here

# Application settings
SPRING_PROFILES_ACTIVE=docker,production
LOG_LEVEL=INFO

• Complete Isolation: All services containerized
• Persistent Storage: Data survives container restarts
• Health Monitoring: Built-in service health checks
• Production Ready: Optimized for enterprise deployment
• Easy Scaling: Docker Swarm or Kubernetes ready
• Development Consistency: Same environment across all machines

# Test application health
curl http://localhost:7860/v1/health

# Test MCP tools endpoint
curl http://localhost:7860/v1/tools

# Access admin interfaces
open http://localhost:7860        # Main application
open http://localhost:7474        # Neo4j browser

1. Build the complete system:

cd a2awebagent
./build-mcp.sh  # Builds both a2acore and a2awebapp

2. Configure Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "professional-resume-agent": {
      "command": "java",
      "args": [
        "-jar",
        "/path/to/a2awebagent/mcp-connector-full.jar",
        "http://localhost:7860/"
      ],
      "timeout": 30000
    }
  }
}

3. Launch and test:

# Start the resume agent
java -jar a2awebapp/target/a2awebapp-0.0.1.jar

# Test professional features
curl http://localhost:7860/v1/tools

• Live Expertise Display: Real-time demonstration of technical capabilities
• Project Portfolio: Interactive exploration of development work
• Skills Validation: AI-powered verification of technical competencies

• LinkedIn Integration: Automated profile search and analysis
• Competitive Analysis: Research industry trends and opportunities
• Technical Documentation: Automated creation of professional materials

• Modern Playwright Implementation: Demonstrating cutting-edge automation
• AI-Powered Error Recovery: Showcasing intelligent problem-solving
• Multi-Protocol Support: A2A and MCP integration expertise

Once running, access the professional features at:

• Main Resume Interface: http://localhost:7860
• Tools Administration: http://localhost:7860/tools (PostgreSQL-cached tool descriptions)
• Agent Analytics: http://localhost:7860/agents (Neo4j async job tracking)
• API Documentation: http://localhost:7860/swagger-ui/index.html
• MCP Tools: curl -X POST http://localhost:7860 -H "Content-Type: application/json" -d '{"jsonrpc": "2.0", "method": "tools/list", "params": {}, "id": 1}'

When properly configured for professional demonstration:

🎯 Professional Resume Agent - Technical Showcase
📋 Available Professional Tools:
  ✅ getWingstonsProjectsExpertiseResume  - Interactive expertise showcase
  ✅ searchLinkedInProfile                - Professional networking research
  ✅ askTasteBeforeYouWaste              - Specialized research capabilities
  ✅ browseWebAndReturnText              - Intelligent web automation
  ✅ browseWebAndReturnImage             - Visual documentation capture
  ✅ webPageAction                       - Advanced Playwright automation

🏗️ Architecture Status:
  ✅ a2acore Framework                   - Fast MCP implementation loaded
  ✅ PostgreSQL Cache                    - Tool descriptions optimized
  ✅ Redis Performance                   - High-speed data caching
  ✅ Playwright Engine                   - Modern web automation ready
  ✅ Multi-AI Integration                - OpenAI/Gemini/Claude available

🌐 Professional Interface: http://localhost:7860
📊 Admin Tools: /tools | /agents

This project showcases enterprise-grade technical implementation:

• ✅ Multi-module Maven structure with separation of concerns
• ✅ Dependency injection with Spring Boot 3.x
• ✅ Protocol abstraction (A2A/MCP support)
• ✅ Performance optimization (PostgreSQL/Redis caching)
• ✅ Error handling & recovery with AI-assisted debugging

• ✅ Code intelligence with Serena integration
• ✅ Database design for scalable caching
• ✅ API design following JSON-RPC standards
• ✅ Security considerations with URL validation
• ✅ Documentation standards with comprehensive README

• ✅ Microsoft Playwright (modern web automation)
• ✅ AI/LLM integration (multiple providers)
• ✅ Real-time communication (WebSocket support)
• ✅ Containerization (Docker support)
• ✅ Protocol compliance (MCP/A2A standards)

# Working directory
cd /Users/wingston/code/a2aTravelAgent/a2awebagent

# Build entire project (both modules)
mvn clean compile

# Run application module specifically
mvn spring-boot:run -pl a2awebapp

# Docker single container rebuild
docker-compose down a2awebagent && docker-compose up --build a2awebagent -d

# Test professional resume features
curl -X POST http://localhost:7860 \
-H "Content-Type: application/json" \
-d '{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "getWingstonsProjectsExpertiseResume",
    "arguments": {
      "query": "Show comprehensive technical expertise and project portfolio"
    }
  },
  "id": 1
}'

# Test LinkedIn professional search
curl -X POST http://localhost:7860 \
-H "Content-Type: application/json" \
-d '{
  "jsonrpc": "2.0", 
  "method": "tools/call",
  "params": {
    "name": "searchLinkedInProfile",
    "arguments": {
      "searchCriteria": "AI engineering expertise"
    }
  },
  "id": 2
}'

• PostgreSQL: Tool description caching with model/tool filtering
• Redis: High-performance session and data caching
• Neo4j: Async job tracking and agent analytics

• CachedMCPToolsController: Bridge between a2acore framework and PostgreSQL
• ToolDescriptionCacheService: Intelligent caching for tool descriptions
• Async Processing: Background job handling for intensive operations

This project demonstrates:

1. Full-Stack Development: From database design to AI integration
2. Modern Architecture: Multi-module, microservices-ready design
3. Protocol Implementation: Standards-compliant MCP/A2A support
4. Performance Engineering: Intelligent caching and optimization
5. AI Integration: Multi-provider LLM capabilities
6. Professional Tools: LinkedIn integration and resume showcase
7. Quality Standards: Comprehensive testing and documentation

This project serves as a living technical resume that demonstrates:

• Advanced Spring Boot architecture with multi-module design
• Modern web automation using Microsoft Playwright
• AI integration expertise across multiple providers
• Database design with PostgreSQL/Redis optimization
• Protocol implementation following MCP/A2A standards
• Professional development practices and code quality

Perfect for demonstrating technical capabilities to potential employers, clients, or collaborators.

This project implements dual protocol support for maximum AI agent interoperability, adhering to both Google's Agent2Agent (A2A) protocol and Anthropic's Model Context Protocol (MCP) specifications.

Official Specification: Google A2A Protocol | A2A Documentation

1. AgentCard Implementation (CustomAgentCardController.java)

   • Endpoint: /v1/agent - Standards-compliant agent discovery
   • Agent Metadata: Name, description, version, capabilities advertisement
   • Capability Advertisement: Streaming support, web automation, professional tools
   • Service Discovery: HTTP-based agent capability publishing

2. Server-Sent Events (SSE) Communication (AgentThoughtController.java)

   • Real-time Streaming: /api/agent-thoughts/stream with text/event-stream
   • Agent Reasoning Display: Live cognitive process broadcasting
   • Task Progress Updates: Asynchronous status notifications
   • Multi-modal Communication: Task-oriented agent coordination

3. Task Delegation & Agent Coordination

   • Web Automation Agents: Playwright-based agents handle delegated browsing tasks
   • Multi-Agent Architecture: Specialized agents for LinkedIn, meme generation, web research
   • Task Management: TaskExecutionIntegrationService handles agent task distribution
   • Distributed Processing: Neo4j-backed agent analytics and coordination logging

4. Agent Discovery & Registry (a2acore framework)

   • Tool Discovery Service: Automatic @Action method scanning and registration
   • Agent Capability Matching: Dynamic tool-to-agent mapping
   • Service Mesh Integration: Spring Boot auto-configuration for agent networks

• HTTP+SSE Communication: Standards-compliant bidirectional agent messaging
• JSON-RPC 2.0 Foundation: Structured inter-agent communication protocol
• AgentCard Publishing: Machine-readable capability advertisement
• Task Lifecycle Management: Comprehensive task state tracking and coordination

Official Specification: Anthropic MCP Docs | MCP Specification

1. JSON-RPC 2.0 Server (A2aCoreController.java)

   • Standards Compliance: Full JSON-RPC 2.0 specification adherence
   • Tool Discovery: tools/list method with schema definitions
   • Tool Execution: tools/call method with parameter validation
   • Error Handling: MCP-compliant error codes and messaging

2. Claude Desktop Integration

   • Node.js MCP Proxy: Official @modelcontextprotocol/sdk implementation
   • Seamless Integration: Ready-to-use Claude Desktop configuration
   • Protocol Bridging: Java backend ↔ Node.js MCP server ↔ Claude Desktop

3. Tool Framework (a2acore MCP Framework)

   • Annotation-Based Discovery: @Action, @Parameter, @EnableA2ACore
   • Automatic Schema Generation: Tool descriptions and input validation
   • Multi-Provider AI Support: OpenAI, Gemini, Claude, Mistral integration
   • Performance Optimization: PostgreSQL caching and Redis acceleration

4. MCP Endpoints & API Structure

   • Primary Endpoint: /v1 - JSON-RPC 2.0 message handling
   • Health Monitoring: /v1/health - Service status and metrics
   • Tool Catalog: /v1/tools - Available tool enumeration
   • Legacy Support: /v1/tools/call - Backward compatibility

• Tool Abstraction: Spring-managed @Action methods as MCP tools
• Schema Validation: Automatic parameter type checking and conversion
• Context Management: Stateful tool execution with progress tracking
• Protocol Translation: Internal framework ↔ MCP specification mapping

• A2A: Enable agent-to-agent communication for distributed AI systems
• MCP: Seamless integration with Claude Desktop and Anthropic ecosystem
• Cross-Protocol: Bridge between Google's A2A and Anthropic's MCP standards
• Future-Proof: Support for both major AI agent communication protocols

• Protocol Expertise: Implementation of two major industry standards
• Standards Compliance: Adherence to official specifications and best practices
• Enterprise Ready: Production-grade protocol implementation with caching, monitoring
• Ecosystem Integration: Compatible with both Google and Anthropic AI agent frameworks

A2A Protocol Resources:

• Google's Agent2Agent GitHub: https://github.com/google/A2A
• Official A2A Documentation: https://a2a.cx/
• A2A Python SDK: https://github.com/a2aproject/a2a-python

MCP Protocol Resources:

• Anthropic MCP Documentation: https://docs.anthropic.com/en/docs/mcp
• MCP Specification: https://modelcontextprotocol.io/specification/
• MCP TypeScript SDK: https://github.com/modelcontextprotocol/sdk

This dual-protocol implementation showcases advanced AI agent communication expertise and enterprise-grade interoperability standards, making it an ideal foundation for building scalable, standards-compliant AI agent systems.

Release Date: December 2024
Status: 🚀 PRODUCTION READY
Documentation: 📚 COMPLETE

✅ Dual Protocol Implementation: Complete A2A + MCP protocol support
✅ Enterprise Architecture: Multi-module Spring Boot with PostgreSQL/Redis/Neo4j
✅ AI Integration: Multi-provider LLM support (OpenAI, Gemini, Claude, Mistral)
✅ Web Automation: Advanced Playwright-based intelligent browsing
✅ Real-time Features: SSE-based live agent reasoning display
✅ Professional Tools: LinkedIn integration, resume showcase, meme generation
✅ Production Deployment: Complete Docker Compose with health monitoring
✅ Security: API key protection, secure authentication patterns
✅ Performance: Intelligent caching, async processing, optimization
✅ Documentation: Comprehensive specs/ folder with professional organization
✅ Testing: Integration tests, health checks, sanity testing

• Protocol Expertise: Successful implementation of Google A2A and Anthropic MCP standards
• Modern Architecture: Clean separation of concerns with a2acore framework abstraction
• Enterprise Patterns: Multi-database integration, caching strategies, async processing
• AI/ML Integration: Sophisticated agent reasoning with real-time cognitive display
• Professional Development: Comprehensive documentation, testing, deployment automation

Future enhancements are organized in specs/reference/v2-planning/ including:

• Enhanced Admin Interface: PostgreSQL tools page, Neo4j analytics dashboard
• Security Improvements: API key logging fixes, audit trail enhancements
• Advanced Features: Enhanced screenshot analysis, mobile responsiveness
• Infrastructure: Kubernetes deployment, advanced monitoring

This v1.0 release represents a complete, production-ready demonstration of:

1. Technical Leadership: Advanced AI agent framework implementation
2. Protocol Mastery: Dual A2A/MCP standard compliance
3. Enterprise Architecture: Scalable, maintainable Spring Boot design
4. Professional Development: Comprehensive documentation and deployment
5. Innovation: Cutting-edge AI integration with real-time reasoning display

Perfect for showcasing advanced Java/Spring Boot expertise, AI/ML integration skills, and enterprise-grade software architecture to potential employers, clients, or collaborators.

🎖️ A2A Travel Agent v1.0 - Professional demonstration of enterprise agentic framework development