Digital Twin Workshop - Simplified Version

Before beginning AI-assisted development, verify these requirements:

✅ GitHub MCP server running in VS Code Insiders
✅ Claude Sonnet 4.0+ model selected in GitHub Copilot
✅ agents.md file created and customized for your project

These components work together to provide context-aware code generation.

Open your agents.md file and make these customizations:

1. Update GitHub repository links to point to YOUR specific RAG solution
2. Add any additional project-specific requirements
3. Verify environment variables match your .env.local file
4. Add any custom business logic or constraints
5. Include specific API endpoints or database schemas you're using

This context helps Copilot generate more accurate, project-specific code.

@workspace Use the instructions in agents.md to help me build the MCP server. Ask me any clarifying questions first. Then, create server actions that implement the RAG functionality using Upstash Vector and Groq as described in the instructions. Start by installing the necessary libraries and then build out the MCP server

**TypeScript Type Errors**
Error: Property 'metadata' does not exist on type 'QueryResult'
Solution: Install proper @upstash/vector types or use type assertions

**Environment Variable Issues**
Error: UPSTASH_VECTOR_REST_URL is undefined
Solution: Verify .env.local file exists and variables are properly set

**MCP Protocol Errors**
Error: Invalid MCP response format
Solution: Ensure response follows MCP specification from roll dice pattern

**Server Action Errors**
Error: Server actions must be async functions
Solution: Add 'use server' directive and ensure proper async/await usage

**Dependency Issues**
Error: Module '@upstash/vector' not found
Solution: Run 'pnpm add @upstash/vector groq' to install dependencies

# Start development server
pnpm dev

# Start development server
pnpm lint

Ask GitHub Copilot to help you:

• Fix any TypeScript errors that appear
• Add comprehensive error handling
• Optimize performance for faster responses
• Add logging and debugging capabilities
• Improve code documentation and comments

Example prompt: '@workspace Review the generated code and add proper error handling for the Upstash Vector queries'

{
  "servers": {
    "digital-twin-mcp": {
      "type": "http",
      "url": "http://localhost:3000/api/mcp",
      "timeout": 30000,
      "description": "Digital Twin RAG MCP Server for interview preparation"
    }
  }
}

# Start development server
pnpm dev

# Start via VS Code MCP Integration
# 1. Open your .vscode/mcp.json file in VS Code Insiders
# 2. You should see a "Start" button/link next to your server configuration
# 3. Click on the "Start" button to launch your MCP server
# 4. VS Code will automatically open the "Output" tab in the Terminal panel
# 5. Monitor the server logs in the Output tab for successful startup

**Successful Startup Logs:**
✅ "Ready in [X]ms" - Next.js server started
✅ "Local: http://localhost:3000" - Server accessible locally
✅ "Compiled successfully" - No TypeScript/build errors

**MCP Endpoint Logs:**
✅ "GET /api/mcp 200" - MCP endpoint responding
✅ "Connected to Upstash Vector successfully!" - Database connection
✅ "Groq client initialized successfully!" - AI client ready

**Error Logs to Watch For:**
❌ "UPSTASH_VECTOR_REST_URL is undefined" - Missing environment variables
❌ "Module not found" - Missing dependencies (run pnpm install)
❌ "Type error" - TypeScript compilation issues
❌ "Connection refused" - Database connection problems

**Testing Your Server:**
• Server responds at http://localhost:3000/api/mcp
• Returns valid JSON-RPC 2.0 response
• No error messages in terminal
• Environment variables loaded correctly

**In VS Code Insiders:**

1. Open Command Palette (Ctrl+Shift+P / Cmd+Shift+P)
2. Search for "GitHub Copilot: Enable MCP Servers"
3. Select your project's .vscode/mcp.json configuration
4. Restart VS Code Insiders to apply MCP settings

**Verify MCP Integration:**
• Check VS Code status bar for MCP connection indicator
• Look for "MCP: Connected" or similar status
• Ensure no error notifications about MCP connection

**Alternative Method:**
• Open VS Code Settings (Ctrl+,)
• Search for "copilot mcp"
• Enable "GitHub Copilot: Use MCP Servers"
• Point to your .vscode/mcp.json file path

@workspace Can you tell me about my work experience using the digital twin MCP server?

@workspace Using my digital twin data, what are my key technical skills?

@workspace Query my digital twin MCP server to help me prepare for a technical interview. What projects should I highlight?

**MCP Server Not Responding:**
• Verify server is running on http://localhost:3000
• Check .vscode/mcp.json file exists and is valid JSON
• Restart VS Code Insiders after creating MCP config
• Ensure no firewall blocking localhost:3000

**GitHub Copilot Not Using MCP:**
• Confirm GitHub Copilot has MCP features enabled
• Check VS Code Insiders version (needs latest version)
• Verify @workspace prefix in prompts
• Try restarting GitHub Copilot extension

**No Digital Twin Responses:**
• Check server logs for Upstash/Groq connection errors
• Verify environment variables in .env.local
• Test /api/mcp endpoint directly in browser
• Ensure digitaltwin.json data was loaded into vector database

**Debugging Commands:**
```bash
# Test MCP endpoint directly
curl -X POST http://localhost:3000/api/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"ping","id":1}'

# Check server logs for errors
pnpm dev --verbose
```

**Job Search Process:**

1. Go to https://www.seek.com.au/ and search for a job that matches your skills
2. Select a role that challenges you but is realistic for your background
3. Choose a posting with detailed requirements and selection criteria
4. Copy the entire job posting content (company name, job description, requirements, etc.)

**Job Selection Tips:**
• Position matches your technical skills (70-80% overlap)
• Has clear key selection criteria listed
• Includes specific technical requirements
• Realistic for your experience level

# Create job-postings folder and file
mkdir job-postings
new-item job-postings\job1.md

# Open the file in VS Code
code job-postings\job1.md

**Instructions:**

1. Open the job1.md file you just created
2. Copy and paste the entire job posting from Seek.com.au
3. Include everything: company name, job title, description, requirements, salary, location
4. Save the file

**What to Include:**
• Complete job description
• All requirements (essential and desirable)
• Company information
• Salary range and location
• Any additional details from the posting

@workspace You are a senior recruiter conducting a comprehensive interview simulation using the job posting in job-postings/job1.md and my digital twin MCP server data.

**INTERVIEW PROCESS:**

**Phase 1 - Initial Screening (5 minutes)**
You are HIGHLY CRITICAL and expect SHORT, SHARP answers. Check these critical factors:
- Location compatibility and willingness to work from specified location
- Salary expectations alignment with the offered range
- ALL mandatory/key selection criteria are met
- Technical skills match the specific requirements
- Experience level appropriate for the role

Ask 3-4 probing screening questions.

**Phase 2 - Technical Assessment (10 minutes)**
Conduct focused technical evaluation:
- Specific programming languages/frameworks mentioned in the job
- Years of experience with required technologies
- Project complexity and scale they've handled
- Problem-solving approach for job scenarios
- Technical leadership experience if required

Provide a technical competency matrix with 1-5 ratings for each required skill.

**Phase 3 - Cultural Fit (5 minutes)**
Analyze behavioral fit:
- Working style compatibility
- Leadership experience vs expectations
- Team collaboration skills
- Communication style
- Career motivation alignment

**Phase 4 - Final Assessment Report**
Provide comprehensive report:

**EXECUTIVE SUMMARY:**
- HIRE/DO NOT HIRE recommendation
- Overall suitability score (1-10)
- Key reasons for recommendation

**DETAILED BREAKDOWN:**
- Technical competency scores
- Experience relevance analysis
- Cultural fit evaluation
- Salary/location alignment
- Risk factors identified

**IMPROVEMENT AREAS:**
- Skills gaps to address
- Missing profile information
- Areas for better interview responses
- Recommended next steps

Be ruthless in your assessment - only recommend candidates who are genuinely suitable for this specific role.

**After completing the interview simulation, review:**

**Performance Analysis:**
• Which questions were answered well vs poorly?
• What skills gaps were identified?
• Were there missing details in your digital twin profile?
• How was your overall suitability score?

**Profile Improvement Actions:**
• Update digitaltwin.json with missing information
• Add specific project examples for weak areas
• Include quantified achievements that were missing
• Strengthen technical knowledge gaps
• Improve storytelling around key experiences

**Next Steps:**
• Try the simulation with different job postings
• Focus on improving your lowest-scored areas
• Update your profile based on feedback
• Practice with more challenging roles

**Critical Profile Enhancement Areas:**

**1. Salary & Location Information**
• Current salary range and expectations
• Location preferences and relocation willingness
• Remote work capabilities and experience
• Travel availability for work assignments
• Visa/work authorization status

**2. Detailed Project Experiences (STAR Format)**
Structure each major project using STAR methodology:
• **Situation**: Project context and business challenge
• **Task**: Your specific role and responsibilities
• **Action**: Detailed steps you took and technologies used
• **Result**: Quantified outcomes and business impact

**3. Enhanced Professional Data Structure**

**Example Enhanced JSON Structure:**
```json
{
  "salary_location": {
    "current_salary_range": "$85,000 - $95,000 AUD",
    "salary_expectations": "$95,000 - $110,000 AUD",
    "location_preferences": ["Melbourne", "Sydney", "Remote"],
    "relocation_willing": true,
    "remote_experience": "3 years full remote work experience",
    "travel_availability": "Up to 25% interstate travel"
  },
  
  "projects_star_format": [
    {
      "project_name": "E-commerce Platform Migration",
      "situation": "Legacy system causing 40% performance issues during peak sales",
      "task": "Lead technical migration to microservices architecture as Senior Developer",
      "action": "Designed new architecture using Node.js, implemented CI/CD pipeline, managed team of 4 developers over 6 months",
      "result": "Improved performance by 60%, reduced deployment time from 4 hours to 15 minutes, increased customer satisfaction by 35%",
      "technologies": ["Node.js", "AWS", "Docker", "MongoDB"],
      "team_size": 4,
      "duration": "6 months",
      "budget_managed": "$450,000"
    }
  ],
  
  "leadership_examples_star": [
    {
      "situation": "Critical production bug affecting 10,000+ users",
      "task": "Coordinate emergency response as technical lead",
      "action": "Assembled cross-functional team, implemented hotfix within 2 hours, conducted post-mortem analysis",
      "result": "Restored service with minimal downtime, prevented $50K revenue loss, improved incident response procedures"
    }
  ]
}
```

**4. Common Missing Information to Add**
• Specific programming language versions and years of experience
• Industry certifications and their expiry dates
• Management experience: team sizes, budget responsibility, hiring experience
• Cross-functional collaboration examples
• Mentoring and training experience
• Open source contributions
• Conference speaking or technical writing
• Agile/Scrum experience with specific roles

**5. Quantification Examples**
• "Reduced server response time from 3s to 0.5s (83% improvement)"
• "Managed annual technology budget of $2.3M across 3 teams"
• "Hired and onboarded 12 developers over 18 months"
• "Increased test coverage from 45% to 92%"
• "Led migration affecting 100,000+ daily active users"

**6. Profile Update Process**
1. Review interview feedback for specific gaps identified
2. Add missing salary/location information using the structure above
3. Convert major achievements into STAR format stories
4. Quantify all achievements with specific metrics
5. Include industry-specific keywords from job postings
6. Add soft skills examples with concrete situations
7. Update technical skills with proficiency levels (1-5 scale)
8. Save updated JSON and re-run your Python embedding script

This comprehensive approach ensures your digital twin can handle detailed recruiter questions about compensation, relocation, and specific project experiences with concrete examples and measurable outcomes.

# Run the embedding script to update vector database
python embed_digitaltwin.py

@workspace Using my updated digital twin MCP server data, can you conduct another comprehensive interview simulation based on the job posting in job-postings/job1.md? Please provide detailed feedback on improvements.

**Testing Different Interviewer Personas:**

**IMPORTANT TIP:** Create a new GitHub Copilot chat session for each interviewer persona to avoid bias from previous answers. This ensures each interview simulation is independent and realistic.

**1. HR/Recruiter Initial Screen (15 minutes)**
*Focus: Cultural fit, basic qualifications, salary expectations*

Prompt:
```
@workspace You are an experienced HR recruiter conducting an initial phone screen. You focus on cultural fit, basic qualifications, and compensation alignment. Use the job posting in job-postings/job1.md and my digital twin MCP server data.

Key areas to assess:
- Cultural alignment with company values
- Basic qualification verification
- Salary expectations vs budget
- Availability and start date
- Motivation for role change
- Communication skills

Conduct a 15-minute screening call with 5-6 questions. Provide pass/fail recommendation with reasoning.
```

**2. Technical Interview (45 minutes)**
*Focus: Technical competency, problem-solving, architecture*

Prompt:
```
@workspace You are a senior software engineer conducting a technical interview. Focus on deep technical assessment using the job posting requirements in job-postings/job1.md and my digital twin MCP server data.

Assessment areas:
- Programming language expertise and best practices
- System design and architecture decisions
- Problem-solving methodology
- Code quality and testing approaches
- Technology stack experience depth
- Technical leadership examples

Ask 4-5 detailed technical questions. Include a system design challenge. Rate technical competency (1-10) for each required skill.
```

**3. Hiring Manager Interview (30 minutes)**
*Focus: Role fit, team dynamics, project experience*

Prompt:
```
@workspace You are the hiring manager for this role. You need someone who can deliver results, work well with your existing team, and grow with the company. Use job-postings/job1.md and my digital twin MCP server data.

Evaluation focus:
- Direct role responsibilities alignment
- Team collaboration and leadership style
- Project management and delivery experience
- Growth potential and career aspirations
- Specific examples of past successes
- How they handle challenges and setbacks

Conduct a focused 30-minute interview. Assess role fit (1-10) and provide hiring recommendation.
```

**4. Project Manager Interview (25 minutes)**
*Focus: Collaboration, communication, project delivery*

Prompt:
```
@workspace You are a project manager who will work closely with this hire. Focus on collaboration, communication, and project delivery capabilities. Reference job-postings/job1.md and my digital twin MCP server data.

Key evaluation areas:
- Cross-functional collaboration experience
- Communication style and clarity
- Meeting deadlines and managing scope
- Stakeholder management skills
- Agile/project methodology experience
- Conflict resolution and problem escalation

Ask 5 scenario-based questions about project situations. Rate collaboration skills (1-10).
```

**5. Head of People & Culture Interview (20 minutes)**
*Focus: Values alignment, team culture, long-term fit*

Prompt:
```
@workspace You are the Head of People & Culture. Your focus is on values alignment, cultural contribution, and long-term employee success. Use job-postings/job1.md and my digital twin MCP server data.

Assessment priorities:
- Company values alignment and demonstration
- Diversity, equity, and inclusion mindset
- Team culture contribution potential
- Long-term career goals alignment
- Learning and development approach
- Work-life balance and well-being

Conduct a values-based interview with 4-5 questions. Assess cultural fit (1-10) and growth potential.
```

**6. Executive/Leadership Interview (25 minutes)**
*Focus: Strategic thinking, leadership potential, business impact*

Prompt:
```
@workspace You are a senior executive (VP/Director level) conducting a final interview. Focus on strategic thinking, leadership potential, and business impact. Reference job-postings/job1.md and my digital twin MCP server data.

Evaluation criteria:
- Strategic thinking and business acumen
- Leadership philosophy and examples
- Innovation and improvement mindset
- Ability to influence without authority
- Long-term vision and goal setting
- Executive presence and communication

Ask 3-4 high-level strategic questions. Assess leadership potential (1-10).
```

**Testing Strategy:**
1. **New Chat Session**: Start fresh GitHub Copilot chat for each persona
2. **Different Days**: Space out interviews over several days for varied responses
3. **Note Patterns**: Track which personas identify similar strengths/weaknesses
4. **Iterate Profile**: Update digital twin based on consistent feedback across personas
5. **Score Tracking**: Maintain spreadsheet of scores across different interview types

**Success Metrics:**
- Technical Interview: 7+ rating on core skills
- Hiring Manager: 8+ role fit score
- HR Screen: Pass recommendation
- Project Manager: 7+ collaboration score
- People & Culture: 8+ cultural fit
- Executive: 6+ leadership potential

This comprehensive approach prepares you for the complete interview process from initial screening to executive approval.

# Verify your MCP server is running
# Navigate to your Next.js MCP project directory
cd your-digital-twin-mcp-project

# Start the development server if not already running
pnpm dev

# Verify server is accessible
# Server should be running at: http://localhost:3000
# MCP endpoint should respond at: http://localhost:3000/api/mcp

# Open a new terminal/PowerShell window
# Run mcp-remote to bridge your local server to Claude Desktop
npx -y mcp-remote http://localhost:3000/api/mcp

# This command will:
# 1. Install mcp-remote if not already installed
# 2. Create a tunnel to your local MCP server
# 3. Provide a URL that Claude Desktop can connect to
# 4. Keep the bridge running (don't close this terminal)

// In Claude Desktop Settings > Developer > MCP Servers:
{
  "mcpServers": {
    "digital-twin-remote": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "http://localhost:3000/api/mcp"],
      "env": {
        "NODE_ENV": "production"
      }
    }
  }
}

// Alternative: Use the tunnel URL provided by mcp-remote
// Replace <tunnel-url> with the actual URL from Step 2
{
  "mcpServers": {
    "digital-twin": {
      "command": "node",
      "args": ["-e", "console.log('MCP server connected')"],
      "env": {
        "MCP_SERVER_URL": "<tunnel-url>"
      }
    }
  }
}

**Test these queries in Claude Desktop:**

1. "Can you tell me about my work experience?"
2. "What are my key technical skills and expertise areas?"
3. "Describe a challenging project I worked on"
4. "What salary range should I expect for my experience level?"
5. "Help me prepare for a technical interview"

**Expected Results:**
• Claude should access your digital twin data via the MCP server
• Responses should be personalized to your professional profile
• Information should match what was tested in VS Code
• Claude should speak in first person about your experience

**Interview Practice Examples:**

**Scenario 1: Behavioral Interview**
"Claude, I have an interview tomorrow. Can you ask me behavioral questions based on my background and help me structure my answers using the STAR method?"

**Scenario 2: Technical Deep Dive**
"Based on my technical experience, what are the most likely technical questions I'll face for a senior developer role? Help me prepare detailed answers."

**Scenario 3: Salary Negotiation**
"Given my experience and location preferences, help me prepare for salary negotiations. What's a reasonable range to request?"

**Scenario 4: Company Research Integration**
"I'm interviewing at [Company Name] for [Role]. Based on my profile, how should I position myself for this specific opportunity?"

**Advantages of Claude Desktop:**
• More natural, conversational interview practice
• Longer context for complex discussions
• Better follow-up questions and coaching
• Seamless integration with your digital twin data

**Common Issues:**

**MCP Server Not Found:**
• Verify mcp-remote is still running (don't close the terminal)
• Ensure your Next.js dev server is running on localhost:3000
• Check Claude Desktop MCP configuration syntax
• Restart Claude Desktop after configuration changes

**No Digital Twin Responses:**
• Verify MCP endpoint responds: http://localhost:3000/api/mcp
• Check server logs for Upstash/Groq connection errors
• Ensure digitaltwin.json was properly embedded
• Test with VS Code first to isolate issues

**Slow or Timeout Responses:**
• Check internet connection for Upstash/Groq API calls
• Verify API keys in .env.local file
• Increase timeout in Claude Desktop configuration
• Monitor server performance in terminal logs

**Debugging Steps:**
1. Test MCP server directly in VS Code first
2. Verify mcp-remote tunnel is active
3. Check Claude Desktop logs/error messages
4. Restart all components in sequence:
   - Next.js dev server
   - mcp-remote bridge
   - Claude Desktop application

**VS Code GitHub Copilot Advantages:**
• Integrated with development workflow
• Excellent for technical deep-dives
• Code-focused interview preparation
• Structured prompt-based interactions
• Better for specific technical assessments

**Claude Desktop Advantages:**
• More natural conversation flow
• Better for behavioral and cultural fit practice
• Longer context retention for complex scenarios
• Superior follow-up questions and coaching
• More human-like interview simulation experience

**Recommended Usage:**
• **Technical Preparation**: Use VS Code for programming questions, system design, and technical competency assessment
• **Interview Practice**: Use Claude Desktop for behavioral questions, salary negotiation, and full interview simulations
• **Profile Refinement**: Use VS Code for analyzing and updating your digital twin JSON structure
• **Conversation Practice**: Use Claude Desktop for natural interview flow and communication skills

**Best Practice:**
Use both interfaces complementary - technical preparation in VS Code, conversation practice in Claude Desktop. This provides comprehensive interview readiness across all dimensions.

# Navigate to your MCP server project directory
cd your-digital-twin-mcp-project

# Install dependencies if needed
pnpm install

# Run the build command to check for errors
pnpm build

# Expected output:
# ✓ Compiled successfully
# ✓ Linting and checking validity of types
# ✓ Creating an optimized production build

# If build succeeds, you're ready for deployment
# If there are errors, fix them before proceeding

# Initialize git repository if not already done
git init

# Add all files to git
git add .

# Commit your changes
git commit -m "Initial commit: Digital Twin MCP Server"

# Create repository on GitHub (go to github.com/new)
# Repository name: your-digital-twin-mcp
# Description: Digital Twin MCP Server for Interview Preparation
# Set as Public or Private (your choice)

# Add GitHub repository as remote (replace YOUR_USERNAME)
git remote add origin https://github.com/YOUR_USERNAME/your-digital-twin-mcp.git

# Push to GitHub
git branch -M main
git push -u origin main

**Vercel Account Setup:**

1. Go to https://vercel.com in your web browser
2. Click "Sign Up" if you don't have an account
3. Choose "Continue with GitHub" for seamless integration
4. Authorize Vercel to access your GitHub repositories
5. Complete your profile setup

**Vercel Dashboard Overview:**
• Projects: Where your deployed applications are listed
• Teams: Collaboration features (use Personal for this project)
• Settings: Account and billing configuration
• Import Git Repository: Main deployment option we'll use

**Import Process:**

1. In Vercel Dashboard, click "Add New..." → "Project"
2. Select "Import Git Repository"
3. Choose "GitHub" as your Git provider
4. Find your "your-digital-twin-mcp" repository
5. Click "Import" next to your repository

**Project Configuration:**
• **Framework Preset**: Next.js (should auto-detect)
• **Root Directory**: ./ (keep default)
• **Build Command**: `pnpm build` (should auto-detect)
• **Output Directory**: .next (should auto-detect)
• **Install Command**: `pnpm install` (should auto-detect)

**Don't deploy yet!** Click "Configure Project" to set environment variables first.

**Environment Variables Setup:**

In the Vercel project configuration, scroll down to "Environment Variables" section:

**Add these variables one by one:**

1. **UPSTASH_VECTOR_REST_URL**
   - Value: [Your Upstash Vector URL from .env.local]
   - Environment: Production, Preview, Development

2. **UPSTASH_VECTOR_REST_TOKEN**
   - Value: [Your Upstash Vector token from .env.local]
   - Environment: Production, Preview, Development

**Important Security Notes:**
• Never commit API keys to your GitHub repository
• Use Vercel's environment variables for secure credential storage
• Each environment variable should be added to all environments (Production, Preview, Development)

**Deployment Process:**

1. After configuring environment variables, click "Deploy"
2. Vercel will:
   - Clone your GitHub repository
   - Install dependencies with `pnpm install`
   - Build your project with `pnpm build`
   - Deploy to their global CDN

**Deployment Timeline:**
• Building: 2-3 minutes
• Deploying: 30-60 seconds
• DNS propagation: Immediate

**Success Indicators:**
✅ "Deployment completed successfully"
✅ Green checkmark next to your project
✅ Live URL provided (e.g., your-digital-twin-mcp.vercel.app)

**Your MCP server will be available at:**
`https://your-project-name.vercel.app/api/mcp`

# Test your live MCP endpoint (replace with your actual Vercel URL)
curl -X POST https://your-digital-twin-mcp.vercel.app/api/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"ping","id":1}'

# Expected response should be valid JSON-RPC format
# If you get errors, check:
# 1. Environment variables are set correctly in Vercel
# 2. Build completed without errors
# 3. All dependencies are properly installed

# Test in browser by visiting:
# https://your-digital-twin-mcp.vercel.app
# Should show your Next.js application homepage

// Update Claude Desktop Settings > Developer > MCP Servers:
// Replace localhost URL with your Vercel deployment URL

{
  "mcpServers": {
    "digital-twin-production": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://your-digital-twin-mcp.vercel.app/api/mcp"],
      "env": {
        "NODE_ENV": "production"
      }
    }
  }
}

// Benefits of production deployment:
// ✅ No need to run local development server
// ✅ Accessible from any device/location
// ✅ Reliable uptime and performance
// ✅ Automatic HTTPS security

// Update .vscode/mcp.json to use production URL:

{
  "servers": {
    "digital-twin-production": {
      "type": "http",
      "url": "https://your-digital-twin-mcp.vercel.app/api/mcp",
      "timeout": 30000,
      "description": "Production Digital Twin RAG MCP Server"
    }
  }
}

// Test in VS Code GitHub Copilot:
// @workspace Can you tell me about my work experience using the production digital twin MCP server?

// Verify the response includes your personalized professional data

**Production Readiness Checklist:**

**✅ Deployment Status:**
• Vercel shows "Deployment completed successfully"
• Live URL is accessible in browser
• No build or runtime errors in Vercel logs

**✅ MCP Endpoint Testing:**
• `/api/mcp` endpoint responds to POST requests
• Returns valid JSON-RPC 2.0 format responses
• No authentication or CORS errors

**✅ Environment Variables:**
• All three API keys configured in Vercel
• Environment variables applied to Production environment
• No sensitive data exposed in client-side code

**✅ Client Integration:**
• Claude Desktop connects successfully to production URL
• VS Code GitHub Copilot can access MCP server
• Digital twin responses are personalized and accurate

**✅ Performance & Reliability:**
• Response times under 5 seconds
• Upstash Vector database connections working
• Groq API calls completing successfully

**🎉 Success!** Your digital twin MCP server is now deployed and accessible 24/7 for interview preparation from anywhere!

**Automatic Deployment Benefits:**
Vercel automatically redeploys your MCP server when you push changes to GitHub.

**How It Works:**
• Push code changes to your GitHub repository
• Vercel detects the changes automatically
• Triggers new build and deployment process
• Updates live server with zero downtime

**Making Updates:**
```bash
# Make changes to your MCP server code
# Test locally first
pnpm dev

# Commit and push changes
git add .
git commit -m "Updated digital twin profile data"
git push origin main

# Vercel will automatically deploy the changes
```

**Monitoring Deployments:**
• View deployment status in Vercel dashboard
• Check build logs for any errors
• Test updated functionality after deployment

**Best Practices:**
• Always test changes locally before pushing
• Use descriptive commit messages
• Monitor Vercel deployment logs for issues
• Keep environment variables synchronized between local and production

**Why Enhance RAG with LLMs?**

**1. Query Preprocessing Benefits:**
• **Intent Understanding**: LLM interprets "What should I highlight?" as "technical achievements, leadership examples, quantified results"
• **Context Expansion**: "Tell me about projects" becomes "technical projects, leadership roles, challenging problems solved, measurable outcomes"
• **Domain Adaptation**: Converts generic questions into interview-specific searches
• **Synonym Enhancement**: Expands "skills" to include "expertise, competencies, technologies, frameworks"

**2. Response Post-Processing Benefits:**
• **Interview Focus**: Transforms technical details into compelling interview stories
• **STAR Format**: Automatically structures responses using Situation-Task-Action-Result methodology
• **Confidence Building**: Adds interview coaching and presentation tips
• **Personalization**: Tailors responses to specific job requirements and company culture

**3. Real-World Impact Examples:**

**Before LLM Enhancement:**
User: "What should I say about my React experience?"
Basic RAG: "You worked with React for 2 years on e-commerce platform"

**After LLM Enhancement:**
User: "What should I say about my React experience?"
Enhanced RAG: "Highlight your React expertise by saying: 'I have 2 years of production React experience building scalable e-commerce platforms. Specifically, I led the migration from class components to hooks, improving code maintainability by 40% and reducing bundle size by 25%. I'm particularly proud of implementing a custom state management solution that handled 10,000+ concurrent users during peak sales periods.'"

**4. Technical Benefits:**
• **Better Search Accuracy**: 60-80% improvement in relevant document retrieval
• **Contextual Responses**: Answers consider job requirements and interview context
• **Reduced Hallucination**: LLM grounds responses in your actual experience data
• **Dynamic Adaptation**: Responses adjust based on interviewer type (technical vs HR vs executive)

# From your existing Python implementation (binal_rag_app.py)
# This shows the pattern you'll replicate in TypeScript

# Query Preprocessing Example:
def enhance_query(user_question):
    enhanced_prompt = f"""
    You are an interview preparation assistant. 
    Improve this question to better search professional profile data:
    
    Original: {user_question}
    
    Enhanced query should:
    - Include relevant synonyms
    - Focus on interview-relevant aspects
    - Expand context for better matching
    
    Return only the enhanced query:
    """
    
    response = groq_client.chat.completions.create(
        messages=[{"role": "user", "content": enhanced_prompt}],
        model="llama-3.1-8b-instant"
    )
    
    return response.choices[0].message.content

# Response Post-processing Example:
def format_for_interview(rag_results, original_question):
    context = "
".join([result['text'] for result in rag_results])
    
    interview_prompt = f"""
    You are an expert interview coach. Use this professional data to create 
    a compelling interview response:
    
    Question: {original_question}
    Professional Data: {context}
    
    Create a response that:
    - Uses STAR format when appropriate
    - Includes specific metrics and achievements
    - Sounds confident and natural
    - Addresses the question directly
    
    Response:
    """
    
    # This pattern shows how to integrate LLM processing
    # You'll adapt this for your TypeScript MCP server

// Enhanced MCP Server Architecture
// This shows the integration points for LLM enhancement

// 1. QUERY PREPROCESSING FLOW:
// User Question → LLM Enhancement → Vector Search → Raw Results

// 2. RESPONSE POSTPROCESSING FLOW:
// Raw Results → LLM Formatting → Interview-Ready Response → User

// Example TypeScript pattern to implement:

export async function enhancedRAGQuery(userQuestion: string) {
  // Step 1: Enhance the query with LLM
  const enhancedQuery = await preprocessQuery(userQuestion);
  
  // Step 2: Perform vector search with enhanced query
  const vectorResults = await searchVectorDatabase(enhancedQuery);
  
  // Step 3: Post-process results with LLM for interview context
  const interviewResponse = await postprocessForInterview(
    vectorResults, 
    userQuestion
  );
  
  return interviewResponse;
}

async function preprocessQuery(originalQuery: string): Promise<string> {
  // Call Groq/Vercel AI to enhance the query
  // Implementation details in next steps
}

async function postprocessForInterview(
  results: VectorResult[], 
  originalQuestion: string
): Promise<string> {
  // Call LLM to format results for interview context
  // Implementation details in next steps
}

# Install Groq SDK for your Next.js MCP project
cd your-digital-twin-mcp-project
pnpm add groq

# Add environment variable to your .env.local
# GROQ_API_KEY=your_groq_api_key_here

# Update your Vercel deployment environment variables:
# Add GROQ_API_KEY to your Vercel project settings

# Groq offers several high-performance models:
# - llama-3.1-8b-instant (fast, good for query enhancement)
# - llama-3.1-70b-versatile (powerful, good for response formatting)
# - mixtral-8x7b-32768 (balanced performance and context)

// lib/llm-enhanced-rag.ts
import Groq from 'groq-sdk';

const groq = new Groq({
  apiKey: process.env.GROQ_API_KEY!,
});

export async function enhanceQuery(originalQuery: string): Promise<string> {
  const enhancementPrompt = `
You are an interview preparation assistant that improves search queries.

Original question: "${originalQuery}"

Enhance this query to better search professional profile data by:
- Adding relevant synonyms and related terms
- Expanding context for interview scenarios
- Including technical and soft skill variations
- Focusing on achievements and quantifiable results

Return only the enhanced search query (no explanation):
  `;

  try {
    const completion = await groq.chat.completions.create({
      messages: [{ role: 'user', content: enhancementPrompt }],
      model: 'llama-3.1-8b-instant',
      temperature: 0.3, // Lower temperature for consistent query enhancement
      max_tokens: 150,
    });

    return completion.choices[0]?.message?.content?.trim() || originalQuery;
  } catch (error) {
    console.error('Query enhancement failed:', error);
    return originalQuery; // Fallback to original query
  }
}

// Example transformations:
// "Tell me about my projects" → 
// "software development projects, technical achievements, leadership roles, problem-solving examples, measurable outcomes, project management, team collaboration, technical challenges overcome"

// Continue in lib/llm-enhanced-rag.ts

export async function formatForInterview(
  ragResults: any[],
  originalQuestion: string
): Promise<string> {
  const context = ragResults
    .map(result => result.data || result.text)
    .join('

');

  const formattingPrompt = `
You are an expert interview coach. Create a compelling interview response using this professional data.

Question: "${originalQuestion}"

Professional Background Data:
${context}

Create a response that:
- Directly addresses the interview question
- Uses specific examples and quantifiable achievements
- Applies STAR format (Situation-Task-Action-Result) when telling stories
- Sounds confident and natural for an interview setting
- Highlights unique value and differentiators
- Includes relevant technical details without being overwhelming

Interview Response:
  `;

  try {
    const completion = await groq.chat.completions.create({
      messages: [{ role: 'user', content: formattingPrompt }],
      model: 'llama-3.1-70b-versatile', // More powerful model for response crafting
      temperature: 0.7, // Higher creativity for natural responses
      max_tokens: 500,
    });

    return completion.choices[0]?.message?.content?.trim() || 'Unable to generate response';
  } catch (error) {
    console.error('Response formatting failed:', error);
    return context; // Fallback to raw RAG results
  }
}

// Example transformation:
// Raw RAG: "React experience: 2 years, e-commerce platform, performance optimization"
// Interview Response: "I have 2 years of production React experience where I was the lead developer on our e-commerce platform. One of my key achievements was optimizing our component architecture, which reduced page load times by 40% and improved our conversion rate by 15%. I'm particularly proud of implementing a custom caching strategy that handled our Black Friday traffic surge of 50,000 concurrent users without any downtime."

// Update your existing MCP server action
// app/actions/digital-twin-actions.ts

import { enhanceQuery, formatForInterview } from '@/lib/llm-enhanced-rag';

export async function enhancedDigitalTwinQuery(question: string) {
  'use server';
  
  try {
    // Step 1: Enhance the user's question for better search
    console.log('Original question:', question);
    const enhancedQuery = await enhanceQuery(question);
    console.log('Enhanced query:', enhancedQuery);
    
    // Step 2: Perform vector search with enhanced query
    const vectorResults = await index.query({
      data: enhancedQuery, // Use enhanced query instead of original
      topK: 5,
      includeMetadata: true,
    });
    
    // Step 3: Format results for interview context
    const interviewResponse = await formatForInterview(
      vectorResults,
      question // Use original question for response context
    );
    
    return {
      success: true,
      response: interviewResponse,
      metadata: {
        originalQuery: question,
        enhancedQuery: enhancedQuery,
        resultsFound: vectorResults.length
      }
    };
  } catch (error) {
    console.error('Enhanced RAG query failed:', error);
    
    // Fallback to basic RAG if LLM enhancement fails
    return await basicDigitalTwinQuery(question);
  }
}

// Keep your existing basic function as fallback
export async function basicDigitalTwinQuery(question: string) {
  // Your existing implementation without LLM enhancement
}

// Create a comparison endpoint in your MCP server
// This helps you evaluate the improvements

export async function compareRAGApproaches(question: string) {
  'use server';
  
  const startTime = Date.now();
  
  // Test both approaches
  const [basicResult, enhancedResult] = await Promise.all([
    basicDigitalTwinQuery(question),
    enhancedDigitalTwinQuery(question)
  ]);
  
  const endTime = Date.now();
  
  return {
    question,
    results: {
      basic: {
        response: basicResult.response,
        processingTime: basicResult.processingTime || 'N/A'
      },
      enhanced: {
        response: enhancedResult.response,
        processingTime: enhancedResult.processingTime || 'N/A',
        enhancedQuery: enhancedResult.metadata?.enhancedQuery
      }
    },
    totalComparisonTime: endTime - startTime
  };
}

// Test prompts for comparison:
// "What are my key strengths?"
// "Tell me about a challenging project"
// "Why should we hire you?"
// "Describe your leadership experience"

// Evaluation criteria:
// - Response specificity and detail
// - Interview relevance and presentation
// - Use of concrete examples and metrics
// - Natural flow and confidence building
// - Processing time and reliability

// lib/rag-config.ts
// Advanced configuration for different interview scenarios

export const RAG_CONFIGS = {
  technical_interview: {
    queryModel: 'llama-3.1-8b-instant',
    responseModel: 'llama-3.1-70b-versatile',
    temperature: 0.3,
    focusAreas: ['technical skills', 'problem solving', 'architecture', 'code quality'],
    responseStyle: 'detailed technical examples with metrics'
  },
  
  behavioral_interview: {
    queryModel: 'llama-3.1-8b-instant', 
    responseModel: 'llama-3.1-70b-versatile',
    temperature: 0.7,
    focusAreas: ['leadership', 'teamwork', 'communication', 'conflict resolution'],
    responseStyle: 'STAR format stories with emotional intelligence'
  },
  
  executive_interview: {
    queryModel: 'llama-3.1-70b-versatile',
    responseModel: 'llama-3.1-70b-versatile', 
    temperature: 0.5,
    focusAreas: ['strategic thinking', 'business impact', 'vision', 'leadership'],
    responseStyle: 'high-level strategic responses with business metrics'
  }
};

// Usage example:
export async function contextAwareRAG(
  question: string, 
  interviewType: keyof typeof RAG_CONFIGS
) {
  const config = RAG_CONFIGS[interviewType];
  
  // Customize prompts based on interview context
  const contextualPrompt = `
    This is a ${interviewType.replace('_', ' ')} question.
    Focus on: ${config.focusAreas.join(', ')}
    Response style: ${config.responseStyle}
    
    Question: ${question}
  `;
  
  // Apply configuration to your RAG pipeline
  return await enhancedDigitalTwinQuery(contextualPrompt);
}

// lib/rag-monitoring.ts
// Production monitoring for your enhanced RAG system

export interface RAGMetrics {
  queryEnhancementTime: number;
  vectorSearchTime: number;
  responseFormattingTime: number;
  totalTime: number;
  tokensUsed: number;
  cacheHitRate: number;
}

export async function monitoredRAGQuery(
  question: string
): Promise<{ response: string; metrics: RAGMetrics }> {
  const metrics: Partial<RAGMetrics> = {};
  const startTime = Date.now();
  
  // Monitor query enhancement
  const enhanceStart = Date.now();
  const enhancedQuery = await enhanceQuery(question);
  metrics.queryEnhancementTime = Date.now() - enhanceStart;
  
  // Monitor vector search
  const searchStart = Date.now();
  const vectorResults = await searchVectorDatabase(enhancedQuery);
  metrics.vectorSearchTime = Date.now() - searchStart;
  
  // Monitor response formatting
  const formatStart = Date.now();
  const formattedResponse = await formatForInterview(vectorResults, question);
  metrics.responseFormattingTime = Date.now() - formatStart;
  
  metrics.totalTime = Date.now() - startTime;
  
  // Log performance metrics
  console.log('RAG Performance Metrics:', metrics);
  
  return {
    response: formattedResponse,
    metrics: metrics as RAGMetrics
  };
}

// Performance optimization tips:
// 1. Cache enhanced queries for common questions
// 2. Use faster models (8B) for query enhancement
// 3. Implement response caching for repeated questions
// 4. Monitor token usage to control costs
// 5. Set timeouts and fallbacks for reliability

**Testing Your Enhanced RAG System**

**Test in VS Code GitHub Copilot:**
```
@workspace Test my enhanced digital twin RAG system with this complex question: "I have an interview for a Senior Full Stack Developer role that requires React, Node.js, and team leadership. The company values innovation and scalability. How should I position my background to show I'm the ideal candidate?"
```

**Test in Claude Desktop:**
"Claude, using my enhanced digital twin system, help me prepare for a technical interview. Ask me follow-up questions and provide coaching on how to improve my responses based on my actual experience."

**Comparison Testing:**
```
@workspace Run both basic and enhanced RAG for this question: "What's my biggest professional achievement?" Compare the responses and analyze the differences in detail and interview readiness.
```

**Success Indicators:**
✅ Enhanced responses include specific metrics and examples
✅ Responses follow interview best practices (STAR format)
✅ Language is confident and interview-appropriate
✅ Technical details are balanced and accessible
✅ Responses directly address the specific question context
✅ Processing time remains under 10 seconds
✅ System gracefully falls back to basic RAG if LLM fails

**Expected Improvements:**
• 60-80% more specific and actionable responses
• Natural interview language and confidence
• Better alignment with job requirements
• Structured storytelling with clear outcomes
• Reduced need for follow-up clarification questions

**Additional Learning Resources:**

**1. Web RAG Deployment Guide (/web-rag-deployment):**
• Production RAG architecture patterns
• LLM integration best practices
• Scalability and performance optimization
• Real-world deployment scenarios
• Advanced RAG techniques and patterns

**2. Advanced RAG Patterns to Explore:**
• **Agentic RAG**: LLM decides when and how to search
• **Multi-hop RAG**: Chain multiple searches for complex questions
• **Contextual RAG**: Maintain conversation history for follow-ups
• **Hybrid Search**: Combine vector and keyword search
• **RAG with Tool Use**: LLM can access external tools and APIs

**3. Production Considerations:**
• **Cost Optimization**: Balance model size vs performance
• **Latency Management**: Parallel processing and caching strategies
• **Quality Assurance**: Automated testing and response evaluation
• **User Personalization**: Adapt responses to user preferences
• **Continuous Learning**: Update embeddings with new experiences

**4. Integration Opportunities:**
• **Calendar Integration**: Prepare for specific upcoming interviews
• **Job Board APIs**: Automatically tailor responses to job postings
• **Company Research**: Incorporate company-specific information
• **Mock Interview Scoring**: AI-powered practice session evaluation
• **Resume Optimization**: Sync improvements between RAG and resume

**🎯 Key Takeaway:**
This enhanced RAG system transforms your digital twin from a simple Q&A tool into an intelligent interview coach that understands context, provides strategic advice, and helps you present your best professional self. The LLM integration creates exponentially more value by bridging the gap between your raw experience data and compelling interview narratives.