PHP全栈AI应用开发实战：构建智能内容生成与推荐系统

PHP在AI时代的技术革新

传统观念认为PHP不适合AI开发，但现代PHP生态通过扩展和微服务架构已实现AI能力的全面集成。本文将展示如何用PHP构建完整的智能内容生成与推荐系统，涵盖从AI模型集成到生产部署的全流程。

系统架构设计

智能应用架构概览

系统分层：
├── 前端交互层
│   ├── Vue.js SPA应用
│   ├── 实时WebSocket通信
│   └── 移动端适配
├── 业务逻辑层
│   ├── Laravel API服务
│   ├── 内容生成引擎
│   ├── 推荐算法服务
│   └── 用户行为分析
├── AI服务层
│   ├── Python AI微服务
│   ├── TensorFlow Serving
│   ├── OpenAI API集成
│   └── 自定义NLP模型
├── 数据存储层
│   ├── MySQL (业务数据)
│   ├── Redis (缓存+向量存储)
│   ├── Elasticsearch (语义搜索)
│   └── MongoDB (非结构化数据)
└── 基础设施层
    ├── Docker容器化
    ├── Kubernetes编排
    ├── 监控告警系统
    └── CI/CD流水线

核心模块实现

1. 智能内容生成引擎

<?php

namespace AppServicesAI;

use GuzzleHttpClient;
use AppContractsContentGenerator;
use AppExceptionsAIServiceException;

class IntelligentContentGenerator implements ContentGenerator
{
    private $httpClient;
    private $cache;
    private $rateLimiter;
    
    public function __construct()
    {
        $this->httpClient = new Client([
            'timeout' => 30.0,
            'verify' => false,
        ]);
        $this->cache = app('redis');
        $this->rateLimiter = new RateLimiter();
    }
    
    /**
     * 智能文章生成
     */
    public function generateArticle(array $params): array
    {
        $cacheKey = $this->generateCacheKey('article', $params);
        
        // 检查缓存
        if ($cached = $this->cache->get($cacheKey)) {
            return json_decode($cached, true);
        }
        
        // 频率限制检查
        if (!$this->rateLimiter->check('ai_generate', 10)) {
            throw new AIServiceException('生成频率过高，请稍后重试');
        }
        
        try {
            // 调用AI服务生成内容
            $prompt = $this->buildArticlePrompt($params);
            $aiResponse = $this->callAIService($prompt, 'article');
            
            // 后处理内容
            $content = $this->postProcessContent($aiResponse, $params);
            
            // 缓存结果
            $this->cache->setex($cacheKey, 3600, json_encode($content));
            
            // 记录生成日志
            $this->logGeneration($params, $content);
            
            return $content;
            
        } catch (Exception $e) {
            throw new AIServiceException("内容生成失败: " . $e->getMessage());
        }
    }
    
    /**
     * 批量内容生成
     */
    public function batchGenerate(array $batchParams): array
    {
        $results = [];
        $promises = [];
        
        foreach ($batchParams as $index => $params) {
            $promises[$index] = $this->asyncGenerate($params);
        }
        
        // 并发处理
        foreach ($promises as $index => $promise) {
            try {
                $results[$index] = $promise->wait();
            } catch (Exception $e) {
                $results[$index] = [
                    'error' => $e->getMessage(),
                    'status' => 'failed'
                ];
            }
        }
        
        return $results;
    }
    
    /**
     * 构建智能提示词
     */
    private function buildArticlePrompt(array $params): string
    {
        $template = "请根据以下要求生成一篇高质量文章：
        
主题：{$params['topic']}
风格：{$params['style']}
长度：{$params['length']}字
目标读者：{$params['audience']}
关键词：{$params['keywords']}
        
要求：
1. 结构清晰，逻辑严谨
2. 语言生动，有感染力
3. 包含实际案例和数据
4. 符合SEO优化要求
5. 结尾要有总结和行动号召
        
请生成：";
        
        return $template;
    }
    
    /**
     * 调用AI服务
     */
    private function callAIService(string $prompt, string $type): array
    {
        $endpoint = config('ai.endpoints.' . $type);
        
        $response = $this->httpClient->post($endpoint, [
            'json' => [
                'prompt' => $prompt,
                'max_tokens' => 2000,
                'temperature' => 0.7,
                'top_p' => 0.9,
                'model' => 'gpt-4',
                'stream' => false
            ],
            'headers' => [
                'Authorization' => 'Bearer ' . config('ai.api_key'),
                'Content-Type' => 'application/json'
            ]
        ]);
        
        $data = json_decode($response->getBody(), true);
        
        if (!isset($data['choices'][0]['text'])) {
            throw new AIServiceException('AI服务响应格式错误');
        }
        
        return [
            'content' => trim($data['choices'][0]['text']),
            'usage' => $data['usage'] ?? [],
            'model' => $data['model'] ?? 'unknown'
        ];
    }
    
    /**
     * 内容后处理
     */
    private function postProcessContent(array $aiResponse, array $params): array
    {
        $content = $aiResponse['content'];
        
        // 智能分段
        $paragraphs = $this->intelligentParagraphSplit($content);
        
        // 提取关键词
        $keywords = $this->extractKeywords($content);
        
        // 生成摘要
        $summary = $this->generateSummary($content);
        
        // 情感分析
        $sentiment = $this->analyzeSentiment($content);
        
        return [
            'title' => $this->generateTitle($content),
            'content' => $content,
            'paragraphs' => $paragraphs,
            'summary' => $summary,
            'keywords' => $keywords,
            'sentiment' => $sentiment,
            'read_time' => $this->calculateReadTime($content),
            'seo_score' => $this->calculateSeoScore($content, $keywords),
            'ai_metadata' => [
                'model' => $aiResponse['model'],
                'usage' => $aiResponse['usage'],
                'generated_at' => now()->toISOString()
            ]
        ];
    }
}

// 智能推荐服务
namespace AppServicesRecommendation;

class HybridRecommender
{
    private $userRepository;
    private $contentRepository;
    private $vectorService;
    
    public function __construct()
    {
        $this->userRepository = app(UserRepository::class);
        $this->contentRepository = app(ContentRepository::class);
        $this->vectorService = app(VectorService::class);
    }
    
    /**
     * 混合推荐算法
     */
    public function getRecommendations(int $userId, int $limit = 10): array
    {
        $user = $this->userRepository->findWithBehavior($userId);
        
        // 并行获取多种推荐结果
        $promises = [
            'collaborative' => $this->getCollaborativeFiltering($user, $limit),
            'content_based' => $this->getContentBased($user, $limit),
            'popular' => $this->getPopularItems($limit),
            'semantic' => $this->getSemanticRecommendations($user, $limit)
        ];
        
        $results = [];
        foreach ($promises as $type => $promise) {
            try {
                $results[$type] = $promise->wait();
            } catch (Exception $e) {
                $results[$type] = [];
            }
        }
        
        // 混合排序和去重
        return $this->hybridRanking($results, $user);
    }
    
    /**
     * 基于内容的推荐
     */
    private function getContentBased(User $user, int $limit): array
    {
        $userPreferences = $this->analyzeUserPreferences($user);
        $userVector = $this->vectorService->textToVector($userPreferences);
        
        // 向量相似度搜索
        $similarItems = $this->vectorService->similaritySearch(
            $userVector, 
            'content_vectors', 
            $limit * 2
        );
        
        return $this->filterAndRank($similarItems, $user);
    }
    
    /**
     * 语义推荐
     */
    private function getSemanticRecommendations(User $user, int $limit): array
    {
        $recentInteractions = $this->userRepository->getRecentInteractions($user->id, 10);
        
        if (empty($recentInteractions)) {
            return [];
        }
        
        // 构建用户兴趣向量
        $interestVectors = [];
        foreach ($recentInteractions as $interaction) {
            $contentVector = $this->vectorService->getContentVector($interaction->content_id);
            if ($contentVector) {
                $interestVectors[] = $contentVector;
            }
        }
        
        if (empty($interestVectors)) {
            return [];
        }
        
        // 计算平均兴趣向量
        $avgVector = $this->vectorService->averageVectors($interestVectors);
        
        // 语义搜索
        return $this->vectorService->semanticSearch($avgVector, $limit);
    }
}

// 用户行为分析服务
namespace AppServicesAnalytics;

class UserBehaviorAnalyzer
{
    private $eventTracker;
    private $patternDetector;
    
    public function __construct()
    {
        $this->eventTracker = app(EventTracker::class);
        $this->patternDetector = app(PatternDetector::class);
    }
    
    /**
     * 实时行为分析
     */
    public function analyzeRealTimeBehavior(int $userId, array $event): void
    {
        $session = $this->getUserSession($userId);
        
        // 更新会话数据
        $session->addEvent($event);
        $session->updateDuration();
        
        // 实时模式检测
        $patterns = $this->patternDetector->detectRealTime($session);
        
        // 触发实时推荐更新
        if ($this->shouldUpdateRecommendations($patterns)) {
            $this->triggerRecommendationUpdate($userId, $patterns);
        }
        
        // 持久化分析结果
        $this->persistAnalysis($userId, $session, $patterns);
    }
    
    /**
     * 用户画像更新
     */
    public function updateUserProfile(int $userId): void
    {
        $recentBehavior = $this->eventTracker->getRecentBehavior($userId, 30);
        $longTermBehavior = $this->eventTracker->getLongTermBehavior($userId, 365);
        
        $profile = [
            'interests' => $this->extractInterests($recentBehavior),
            'preferences' => $this->analyzePreferences($longTermBehavior),
            'behavior_patterns' => $this->detectPatterns($recentBehavior, $longTermBehavior),
            'engagement_level' => $this->calculateEngagement($recentBehavior),
            'value_segment' => $this->segmentUser($recentBehavior, $longTermBehavior),
            'last_updated' => now()->toISOString()
        ];
        
        $this->saveUserProfile($userId, $profile);
    }
}

2. AI模型服务集成

<?php

namespace AppServicesAIIntegrations;

class AIModelOrchestrator
{
    private $models = [];
    private $fallbackStrategy;
    
    public function __construct()
    {
        $this->initializeModels();
        $this->fallbackStrategy = new FallbackStrategy();
    }
    
    /**
     * 多模型智能路由
     */
    public function intelligentRoute(string $task, array $input): array
    {
        // 选择最优模型
        $model = $this->selectOptimalModel($task, $input);
        
        try {
            $result = $model->process($input);
            
            // 质量评估
            $qualityScore = $this->evaluateQuality($result, $task);
            
            if ($qualityScore >= 0.7) {
                return [
                    'result' => $result,
                    'model' => get_class($model),
                    'quality_score' => $qualityScore,
                    'confidence' => $this->calculateConfidence($result)
                ];
            } else {
                // 质量不足，尝试备用模型
                return $this->fallbackStrategy->execute($task, $input, $result);
            }
            
        } catch (Exception $e) {
            // 模型失败，执行降级策略
            return $this->fallbackStrategy->handleFailure($task, $input, $e);
        }
    }
    
    /**
     * 模型性能监控
     */
    public function monitorModelPerformance(): array
    {
        $metrics = [];
        
        foreach ($this->models as $name => $model) {
            $metrics[$name] = [
                'success_rate' => $model->getSuccessRate(),
                'avg_response_time' => $model->getAvgResponseTime(),
                'error_rate' => $model->getErrorRate(),
                'cost_per_request' => $model->getCostPerRequest(),
                'last_health_check' => $model->getHealthStatus()
            ];
        }
        
        return $metrics;
    }
}

// 向量数据库服务
namespace AppServicesVector;

class RedisVectorService
{
    private $redis;
    private $dimension;
    
    public function __construct()
    {
        $this->redis = app('redis');
        $this->dimension = 1536; // OpenAI embedding dimension
    }
    
    /**
     * 存储向量数据
     */
    public function storeVector(string $namespace, string $id, array $vector): bool
    {
        $key = "vector:{$namespace}:{$id}";
        
        // 验证向量维度
        if (count($vector) !== $this->dimension) {
            throw new InvalidArgumentException("向量维度不匹配");
        }
        
        // 存储向量数据
        $result = $this->redis->set(
            $key, 
            json_encode([
                'vector' => $vector,
                'metadata' => [
                    'stored_at' => now()->toISOString(),
                    'dimension' => $this->dimension,
                    'namespace' => $namespace
                ]
            ])
        );
        
        // 添加到向量索引
        $this->addToIndex($namespace, $id, $vector);
        
        return $result;
    }
    
    /**
     * 相似度搜索
     */
    public function similaritySearch(array $queryVector, string $namespace, int $limit = 10): array
    {
        $candidates = $this->getCandidatesFromIndex($namespace, $queryVector, $limit * 3);
        
        $results = [];
        foreach ($candidates as $candidateId) {
            $vectorData = $this->getVector($namespace, $candidateId);
            if ($vectorData) {
                $similarity = $this->cosineSimilarity($queryVector, $vectorData['vector']);
                $results[] = [
                    'id' => $candidateId,
                    'similarity' => $similarity,
                    'metadata' => $vectorData['metadata']
                ];
            }
        }
        
        // 按相似度排序
        usort($results, function ($a, $b) {
            return $b['similarity']  $a['similarity'];
        });
        
        return array_slice($results, 0, $limit);
    }
    
    /**
     * 余弦相似度计算
     */
    private function cosineSimilarity(array $a, array $b): float
    {
        $dotProduct = 0;
        $normA = 0;
        $normB = 0;
        
        for ($i = 0; $i dimension; $i++) {
            $dotProduct += $a[$i] * $b[$i];
            $normA += $a[$i] * $a[$i];
            $normB += $b[$i] * $b[$i];
        }
        
        if ($normA == 0 || $normB == 0) {
            return 0;
        }
        
        return $dotProduct / (sqrt($normA) * sqrt($normB));
    }
}

// 实时WebSocket服务
namespace AppServicesWebSocket;

class RealTimeAIService
{
    private $server;
    private $aiOrchestrator;
    
    public function __construct()
    {
        $this->server = app('websocket');
        $this->aiOrchestrator = app(AIModelOrchestrator::class);
    }
    
    /**
     * 处理实时AI请求
     */
    public function handleRealTimeRequest($connection, $data): void
    {
        $requestId = $data['request_id'] ?? uniqid();
        $task = $data['task'] ?? 'unknown';
        
        try {
            // 发送开始处理通知
            $this->sendMessage($connection, [
                'type' => 'processing_started',
                'request_id' => $requestId,
                'timestamp' => now()->toISOString()
            ]);
            
            // 流式处理
            if ($data['stream'] ?? false) {
                $this->handleStreamingResponse($connection, $requestId, $task, $data);
            } else {
                $this->handleStandardResponse($connection, $requestId, $task, $data);
            }
            
        } catch (Exception $e) {
            $this->sendError($connection, $requestId, $e->getMessage());
        }
    }
    
    /**
     * 流式响应处理
     */
    private function handleStreamingResponse($connection, string $requestId, string $task, array $data): void
    {
        $chunkSize = $data['chunk_size'] ?? 100;
        $totalTokens = 0;
        
        // 模拟流式输出
        $result = $this->aiOrchestrator->intelligentRoute($task, $data);
        $content = $result['result']['content'] ?? '';
        
        $chunks = str_split($content, $chunkSize);
        
        foreach ($chunks as $index => $chunk) {
            $this->sendMessage($connection, [
                'type' => 'stream_chunk',
                'request_id' => $requestId,
                'chunk' => $chunk,
                'chunk_index' => $index,
                'is_final' => $index === count($chunks) - 1,
                'timestamp' => now()->toISOString()
            ]);
            
            // 模拟处理延迟
            usleep(100000); // 100ms
            
            $totalTokens += count(explode(' ', $chunk));
        }
        
        // 发送完成通知
        $this->sendMessage($connection, [
            'type' => 'stream_complete',
            'request_id' => $requestId,
            'total_tokens' => $totalTokens,
            'final_metrics' => $result,
            'timestamp' => now()->toISOString()
        ]);
    }
}

性能优化与监控

1. AI服务缓存策略

<?php

namespace AppServicesCache;

class AICacheManager
{
    private $cache;
    private $vectorCache;
    
    public function __construct()
    {
        $this->cache = app('cache');
        $this->vectorCache = app('redis');
    }
    
    /**
     * 智能缓存策略
     */
    public function getWithIntelligentCaching(string $key, callable $callback, array $context): mixed
    {
        // 检查缓存
        $cached = $this->getFromCache($key, $context);
        if ($cached !== null) {
            $this->recordCacheHit($key, $context);
            return $cached;
        }
        
        // 执行回调获取数据
        $result = $callback();
        
        // 智能决定是否缓存
        if ($this->shouldCache($result, $context)) {
            $ttl = $this->calculateOptimalTTL($result, $context);
            $this->storeInCache($key, $result, $ttl, $context);
        }
        
        $this->recordCacheMiss($key, $context);
        return $result;
    }
    
    /**
     * 向量缓存管理
     */
    public function cacheVectors(array $vectors, string $namespace): void
    {
        $pipeline = $this->vectorCache->pipeline();
        
        foreach ($vectors as $id => $vector) {
            $key = "vector:{$namespace}:{$id}";
            $pipeline->setex(
                $key, 
                86400, // 24小时
                json_encode([
                    'vector' => $vector,
                    'cached_at' => now()->toISOString()
                ])
            );
        }
        
        $pipeline->execute();
    }
}

// 性能监控服务
namespace AppServicesMonitoring;

class AIPerformanceMonitor
{
    private $metrics = [];
    
    /**
     * 记录AI服务指标
     */
    public function recordMetrics(string $service, array $metrics): void
    {
        $timestamp = now()->timestamp;
        
        $this->metrics[$service][] = [
            'timestamp' => $timestamp,
            'metrics' => $metrics
        ];
        
        // 清理旧数据
        $this->cleanupOldMetrics();
    }
    
    /**
     * 生成性能报告
     */
    public function generatePerformanceReport(): array
    {
        $report = [];
        
        foreach ($this->metrics as $service => $data) {
            $report[$service] = [
                'total_requests' => count($data),
                'avg_response_time' => $this->calculateAverage($data, 'response_time'),
                'success_rate' => $this->calculateSuccessRate($data),
                'cost_per_request' => $this->calculateAverageCost($data),
                'peak_usage' => $this->findPeakUsage($data),
                'trend' => $this->analyzeTrend($data)
            ];
        }
        
        return $report;
    }
}

部署与运维

1. Docker多服务编排

# docker-compose.ai.yml
version: '3.8'

services:
  # PHP应用服务
  php-app:
    build:
      context: .
      dockerfile: Dockerfile.php
    image: ai-content-app:latest
    environment:
      - APP_ENV=production
      - AI_API_ENDPOINT=http://ai-service:8000
      - REDIS_HOST=redis
      - MYSQL_HOST=mysql
    volumes:
      - ./storage:/var/www/storage
    depends_on:
      - mysql
      - redis
      - ai-service

  # AI微服务
  ai-service:
    build:
      context: ./ai-service
      dockerfile: Dockerfile.python
    image: ai-model-service:latest
    environment:
      - MODEL_PATH=/app/models
      - CACHE_HOST=redis
    volumes:
      - ./ai-models:/app/models
    deploy:
      resources:
        limits:
          memory: 8G
          cpus: '4.0'

  # 向量搜索服务
  vector-service:
    image: redis/redis-stack:latest
    ports:
      - "8001:8001"
    volumes:
      - vector-data:/data

  # 监控服务
  monitoring:
    image: prom/prometheus:latest
    ports:
      - "9090:9090"
    volumes:
      - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml

volumes:
  vector-data: