1. Member profile text → OpenAI text-embedding-3-small → vector(1536)
2. Store vector in member_profiles.embedding
3. Match query: cosine similarity search via pgvector operator <=>
4. Filter: active, not connected, not blocked, different user
5. Cache results in Redis for 24h
6. Weekly BullMQ job refreshes all embeddings

function buildProfileText(profile: MemberProfileEntity): string {
  return [
    profile.displayName,
    profile.tagline,
    profile.bio,
    profile.businessNiche,
    profile.skills?.join(', '),
    profile.industries?.join(', '),
    profile.revenueStage,
    profile.availabilityStatus,
  ]
    .filter(Boolean)
    .join('. ');
}
// Example output:
// "Marcus Webb. E-com operator | $500K/mo Shopify brand.
//  Been building Shopify brands since 2019. E-commerce.
//  Paid Ads, Shopify, Team Building, Brand Strategy.
//  1m_plus. open_to_deals."

async generateEmbedding(text: string): Promise<number[]> {
  const response = await this.openai.embeddings.create({
    model: 'text-embedding-3-small',  // 1536 dimensions, cheap ($0.02/1M tokens)
    input: text,
  });
  return response.data[0].embedding;
}

// TypeORM entity column
@Column({ type: 'vector', length: 1536, nullable: true })
embedding: number[];

// TypeORM cannot handle vector type natively — use raw query for updates:
await this.dataSource.query(
  `UPDATE member_profiles SET embedding = $1::vector, embedding_updated_at = NOW() WHERE user_id = $2`,
  [`[${embedding.join(',')}]`, userId],
);

async getMatchesForUser(
  userId: string,
  limit = 10,
): Promise<MemberProfileEntity[]> {
  // Check Redis cache first
  const cacheKey = `matches:${userId}`;
  const cached = await this.redis.get(cacheKey);
  if (cached) return JSON.parse(cached);

  // Get the requesting user's embedding
  const [userProfile] = await this.dataSource.query(
    `SELECT embedding FROM member_profiles WHERE user_id = $1`,
    [userId],
  );
  if (!userProfile?.embedding) return [];

  // Find similar profiles using cosine distance
  // Exclude: self, already connected, blocked users, inactive users
  const matches = await this.dataSource.query(
    `
    SELECT
      mp.*,
      u.membership_tier,
      u.status,
      (mp.embedding <=> $1::vector) AS distance
    FROM member_profiles mp
    JOIN users u ON u.id = mp.user_id
    WHERE
      mp.user_id != $2
      AND u.status = 'active'
      AND mp.embedding IS NOT NULL
      AND mp.user_id NOT IN (
        SELECT CASE
          WHEN requester_id = $2 THEN addressee_id
          ELSE requester_id
        END
        FROM member_connections
        WHERE (requester_id = $2 OR addressee_id = $2)
          AND status IN ('accepted', 'blocked')
      )
    ORDER BY mp.embedding <=> $1::vector
    LIMIT $3
    `,
    [userProfile.embedding, userId, limit],
  );

  // Cache for 24 hours
  await this.redis.setex(cacheKey, 86400, JSON.stringify(matches));

  return matches;
}

// In MembersService.updateProfile():
await this.embeddingsQueue.add('generate', { userId }, {
  delay: 5000,         // Wait 5s in case of rapid updates
  jobId: `embed:${userId}`,  // Deduplicates — if job exists, skip
});

// In ReputationModule or a dedicated SchedulerService:
@Cron(CronExpression.EVERY_WEEK)
async refreshAllEmbeddings() {
  const activeUsers = await this.userRepo.find({
    where: { status: 'active' },
    select: ['id'],
  });

  for (const user of activeUsers) {
    await this.embeddingsQueue.add('generate', { userId: user.id }, {
      delay: Math.random() * 60000,  // Spread load over 1 minute
    });
  }
}

@Processor('embeddings')
export class EmbeddingProcessor {
  @Process('generate')
  async handleGenerate(job: Job<{ userId: string }>) {
    const { userId } = job.data;

    // Load profile
    const profile = await this.profileRepo.findOne({ where: { userId } });
    if (!profile) return;

    // Build text and generate embedding
    const text = buildProfileText(profile);
    const embedding = await this.openaiService.generateEmbedding(text);

    // Save to DB
    await this.dataSource.query(
      `UPDATE member_profiles SET embedding = $1::vector, embedding_updated_at = NOW() WHERE user_id = $2`,
      [`[${embedding.join(',')}]`, userId],
    );

    // Invalidate match cache for this user
    await this.redis.del(`matches:${userId}`);

    this.logger.log(`Embedding updated for user ${userId}`);
  }
}

-- Created in 01-init.sql
-- ivfflat is faster than exact search for large datasets
-- lists=100 is good for up to ~1M rows
CREATE INDEX idx_profiles_embedding
ON member_profiles
USING ivfflat (embedding vector_cosine_ops)
WITH (lists = 100);

-- For exact search (slower but more accurate, use at <10K rows):
-- USING hnsw (embedding vector_cosine_ops)

OPENAI_API_KEY=sk-...    # Required for AI features
                          # Leave blank to disable embeddings (safe in dev)

async getMatchesForUser(userId: string, limit = 10) {
  if (!this.configService.get('openai.apiKey')) {
    // Skill-overlap fallback
    const userProfile = await this.profileRepo.findOne({ where: { userId } });
    return this.profileRepo
      .createQueryBuilder('p')
      .where('p.userId != :userId', { userId })
      .andWhere('p.skills && :skills', { skills: userProfile.skills })
      .orderBy('RANDOM()')
      .limit(limit)
      .getMany();
  }
  // ... full AI match logic
}