Building an HR Team-Matching Agent With MongoDB Vector Search, Voyage AI, & Vercel AI SDK

import { voyage } from 'voyage-ai-provider';
import { embedMany } from 'ai';

const embeddingModel = voyage.textEmbeddingModel('voyage-3');

export const generateEmbeddings = async (
  value: string,
): Promise<Array<{ embedding: number[]; content: string }>> => {
  // Generate chunks from the input value
  const chunks = value.split('\n');
  const { embeddings } = await embedMany({
    model: embeddingModel,
    values: chunks,
  });

  return embeddings.map((e, i) => ({ content: chunks[i], embedding: e }));
};

async function generateSkillEmbeddings(employees: Array<Omit<Employee, '_id'>>) {
  for (const employee of employees) {
    try {
      // Create combined skill description using | as separator
      const skillDescriptions = employee.skills.map(skill =>
        `${skill.name}: ${skill.proficiency}/5 proficiency with ${skill.yearsExperience} years experience in contexts like ${skill.contexts.join(', ')}`
      );

      const combinedSkillDescription = skillDescriptions.join(' | ');

      // Generate embedding for all skills combined
      const embeddingResults = await generateEmbeddings(combinedSkillDescription);

      // Add the embedding to the employee document at the top level
      if (embeddingResults.length > 0) {
        (employee as any).embedding = embeddingResults[0].embedding;
        console.log(`✅ Generated top-level embedding for ${employee.name}'s combined skills`);
      } else {
        console.warn(`⚠️ No embeddings generated for ${employee.name}'s combined skills`);
        (employee as any).embedding = [];
      }
    } catch (error) {
      console.error(`❌ Error generating embedding for ${employee.name}'s skills:`, error);
      // Set an empty embedding as fallback
      (employee as any).embedding = [];
    }
  }

  return employees;
}

async function updateEmployeeSkillEmbeddings(employee) {
  const employeesWithEmbeddings = await generateSkillEmbeddings(employee);

  // Update employee record in MongoDB
  await db.employees.updateOne(
    { _id: employee._id },
    { $set: { embedding: employeesWithEmbeddings.embedding } }
  );
}

// types.ts - Database schema definitions
export interface Employee {
  _id?: ObjectId;
  name: string;
  title: string;
  department: string;
  email: string;
  hireDate: Date;
  availability: number; // percentage available for new projects
  skills: Skill[];
  performance: {
    rating: number; // 1-5 scale
    teamworkScore: number; // 1-5 scale
    lastReviewDate: Date;
  };
  pastProjects: {
    projectId: ObjectId;
    role: string;
    contribution: string;
  }[];
  teamHistory: ObjectId[]; // IDs of employees they've worked with
  embedding: number[]; // Combined skills embedding at the top level
}

export interface Team {
  _id?: ObjectId;
  projectTitle: string;
  projectDescription: string;
  createdAt: Date;
  members: {
    name: string;
    role: string;
    keySkills: string[];
    justification: string;
  }[];
  skillCoverage: number;
  overallRationale: string;
  risks: string[];
  mitigationStrategies: string[];
  status: 'proposed' | 'approved' | 'active' | 'completed';
}

// Vector search index configuration via atlas UI called `skill_vector_index`
{
  "fields": [
    {
      "type": "vector",
      "path": "embedding",
      "numDimensions": 1024,
      "similarity": "cosine"
    }
  ]
}

const embedding = await generateEmbeddings(query)

// Perform vector search with additional filters
const matchingEmployees = await employeesCollection.aggregate([
  {
    $vectorSearch: {
      index: "skills_vector_index",
      path: "embedding",
      queryVector: embedding,
      numCandidates: 100,
      limit: 20
    }
  },
  // Filter by proficiency and availability
  {
    $match: {
      "skills.proficiency": { $gte: minProficiency },
      "availability": { $gte: minAvailability }
    }
  },
  // Project relevant fields
  {
    $project: {
      _id: 1,
      name: 1,
      title: 1,
      department: 1,
      availability: 1,
      hireDate: 1,
      performance: 1,
      relevantSkills: {
        $filter: {
          input: "$skills",
          as: "skill",
          cond: { $gte: ["$$skill.proficiency", minProficiency] }
        }
      },
      pastProjects: 1,
      teamHistory: 1,
      similarity: { $meta: "vectorSearchScore" }
    }
  },
  // Sort by similarity score
  {
    $sort: {
      similarity: -1
    }
  }
]).toArray();

return matchingEmployees;

import { tool } from 'ai';
import { z } from 'zod';
import { MongoClient, ObjectId } from 'mongodb';
import { voyage } from 'voyage-ai-provider';
import { embedMany } from 'ai';
import {
  calculateSkillCoverage,
  calculateTeamDiversity,
  analyzeCollaborationHistory,
  calculateTeamScore,
  generateTeamAnalysis
} from './teamAnalysis';
import { Employee, Team } from './types';
import { generateEmbeddings } from './embeddings';

// Initialize MongoDB connection
const mongoClient = new MongoClient(process.env.MONGODB_URI!);
const db = mongoClient.db('hr_database');
const employeesCollection = db.collection<Employee>('employees');
const teamsCollection = db.collection<Team>('teams');

// Tool 1: Project Requirements Analysis

// Tool 2: Skill Search with MongoDB Vector Search
export const searchEmployeesBySkill = tool({
  description: 'Searches for employees with specific skills using semantic matching.',
  parameters: z.object({
    skillDescription: z.string().describe('Description of the required skill'),
    minProficiency: z.number().describe('Minimum proficiency level (1-5)'),
    minAvailability: z.number().describe('Minimum availability percentage')
  }),
  execute: async ({ skillDescription, minProficiency = 3, minAvailability = 20 }) => {
    try {
      // Generate embedding for the skill description using Voyage AI
      const embeddingResults = await generateEmbeddings(skillDescription);
      if (embeddingResults.length === 0) {
        return { error: "Failed to generate embedding for skill description" };
      }
      const embedding = embeddingResults[0].embedding;

      // Perform vector search with additional filters
      const matchingEmployees = await employeesCollection.aggregate([
        {
          $vectorSearch: {
            index: "skills_vector_index",
            path: "embedding",
            queryVector: embedding,
            numCandidates: 100,
            limit: 20
          }
        },
        // Filter by proficiency and availability
        {
          $match: {
            "skills.proficiency": { $gte: minProficiency },
            "availability": { $gte: minAvailability }
          }
        },
        // Project relevant fields
        {
          $project: {
            _id: 1,
            name: 1,
            title: 1,
            department: 1,
            availability: 1,
            hireDate: 1,
            performance: 1,
            relevantSkills: {
              $filter: {
                input: "$skills",
                as: "skill",
                cond: { $gte: ["$$skill.proficiency", minProficiency] }
              }
            },
            pastProjects: 1,
            teamHistory: 1,
            similarity: { $meta: "vectorSearchScore" }
          }
        }
      ]).toArray();

      return matchingEmployees;
    } catch (error) {
      console.error("Error searching for employees:", error);
      return { error: "Failed to search for employees" };
    }
  },
});

// Tool 3: Team Composition Analysis

// Tool 4: Database Integration - Save Team

// Tool 5: Team Recommendation (structured output)