analyze_bioimpedance_pdf_base64

Instructions

Implementation Reference

• src/tools/pdf.tools.ts:88-159 (handler)

  MCP tool handler for 'analyze_bioimpedance_pdf_base64'. Defines input schema with Zod, executes PDF analysis from base64 data using PDFAnalysisService, and returns structured JSON response with health metrics, analysis, and recommendations.

  analyze_bioimpedance_pdf_base64: {
    description: 'Analyze a bioimpedance PDF document from base64-encoded data',
    parameters: z.object({
      base64Data: z.string().describe('Base64-encoded PDF data'),
      patientId: z.string().optional().describe('Optional patient ID for reference')
    }),
    execute: async (args: { base64Data: string; patientId?: string }) => {
      try {
        logger.info('Analyzing bioimpedance PDF from base64', {
          patientId: args.patientId,
          dataLength: args.base64Data.length
        });
  
        validateNotEmpty(args.base64Data, 'Base64 data');
  
        const analysis = await pdfService.analyzeBioimpedancePDFFromBase64(args.base64Data);
  
        return {
          content: [
            {
              type: 'text',
              text: JSON.stringify(
                {
                  success: true,
                  patientId: args.patientId,
                  analysis: {
                    patientInfo: {
                      name: analysis.patientName,
                      date: analysis.date
                    },
                    measurements: {
                      weight: analysis.weight ? `${analysis.weight} kg` : 'N/A',
                      height: analysis.height ? `${analysis.height} cm` : 'N/A',
                      bmi: analysis.bmi || 'N/A',
                      bodyFatPercentage: analysis.bodyFatPercentage ? `${analysis.bodyFatPercentage}%` : 'N/A',
                      muscleMassPercentage: analysis.muscleMassPercentage ? `${analysis.muscleMassPercentage}%` : 'N/A',
                      boneMass: analysis.boneMass ? `${analysis.boneMass} kg` : 'N/A',
                      bodyWaterPercentage: analysis.bodyWaterPercentage ? `${analysis.bodyWaterPercentage}%` : 'N/A',
                      visceralFat: analysis.visceralFat || 'N/A',
                      bmr: analysis.bmr ? `${analysis.bmr} kcal` : 'N/A'
                    },
                    analysis: analysis.analysis,
                    recommendations: analysis.recommendations
                  }
                },
                null,
                2
              )
            }
          ]
        };
      } catch (error) {
        logger.error('Failed to analyze bioimpedance PDF from base64', error);
        return {
          content: [
            {
              type: 'text',
              text: JSON.stringify(
                {
                  success: false,
                  error: error instanceof Error ? error.message : 'Unknown error'
                },
                null,
                2
              )
            }
          ],
          isError: true
        };
      }
    }
  }

• src/index.ts:60-68 (registration)

  Registers the PDF tools (including analyze_bioimpedance_pdf_base64) by calling createPDFTools and merging into the allTools object used by MCP server handlers.

  const ticketTools = createTicketTools(apiService);
  const chatbotTools = createChatbotTools(chatbotService);
  const pdfTools = createPDFTools(pdfService);
  
  const allTools = {
    ...ticketTools,
    ...chatbotTools,
    ...pdfTools
  };

• src/services/pdf-analysis.service.ts:260-295 (helper)

  Core service method that implements the bioimpedance PDF analysis from base64: decodes data, parses PDF text, extracts measurements using regex patterns, generates analysis/recommendations, optionally enhances with AI.

  async analyzeBioimpedancePDFFromBase64(base64Data: string): Promise<BioimpedanceData> {
    try {
      logger.info('Starting PDF analysis from base64');
  
      // Decode base64 to buffer
      const buffer = Buffer.from(base64Data, 'base64');
      
      // Create parser and extract text
      const pdfParser = new PDFParse({ data: buffer });
      const textResult = await pdfParser.getText();
  
      logger.debug('PDF parsed successfully', {
        pages: textResult.pages.length,
        textLength: textResult.text.length
      });
  
      // Extract bioimpedance data from text
      const extractedData = this.extractBioimpedanceData(textResult.text);
  
      // Generate analysis and recommendations
      const insights = await this.enhanceWithAI(extractedData);
      const { analysis, recommendations } = insights;
  
      const result: BioimpedanceData = {
        ...extractedData,
        analysis,
        recommendations
      };
  
      logger.info('PDF analysis completed successfully');
      return result;
    } catch (error) {
      logger.error('Failed to analyze PDF from base64', error);
      throw new Error(`PDF analysis failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
    }
  }

• src/services/pdf-analysis.service.ts:58-133 (helper)

  Helper method that uses regex patterns to extract key bioimpedance measurements (patient info, weight, height, BMI, body fat %, muscle %, etc.) from parsed PDF text.

  private extractBioimpedanceData(text: string): Omit<BioimpedanceData, 'analysis' | 'recommendations'> {
    const data: Omit<BioimpedanceData, 'analysis' | 'recommendations'> = {};
  
    // Extract patient name
    const nameMatch = text.match(/(?:paciente|patient|nome|name)[:\s]+([^\n]+)/i);
    if (nameMatch) {
      data.patientName = nameMatch[1].trim();
    }
  
    // Extract date
    const dateMatch = text.match(/(?:data|date)[:\s]+(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2,4})/i);
    if (dateMatch) {
      data.date = dateMatch[1];
    }
  
    // Extract weight (kg)
    const weightMatch = text.match(/(?:peso|weight)[:\s]+(\d+(?:\.\d+)?)\s*(?:kg)?/i);
    if (weightMatch) {
      data.weight = parseFloat(weightMatch[1]);
    }
  
    // Extract height (cm)
    const heightMatch = text.match(/(?:altura|height)[:\s]+(\d+(?:\.\d+)?)\s*(?:cm)?/i);
    if (heightMatch) {
      data.height = parseFloat(heightMatch[1]);
    }
  
    // Extract body fat percentage
    const bodyFatMatch = text.match(/(?:gordura corporal|body fat|%\s*gordura)[:\s]+(\d+(?:\.\d+)?)\s*%?/i);
    if (bodyFatMatch) {
      data.bodyFatPercentage = parseFloat(bodyFatMatch[1]);
    }
  
    // Extract muscle mass percentage
    const muscleMassMatch = text.match(/(?:massa muscular|muscle mass|%\s*m[uú]sculo)[:\s]+(\d+(?:\.\d+)?)\s*%?/i);
    if (muscleMassMatch) {
      data.muscleMassPercentage = parseFloat(muscleMassMatch[1]);
    }
  
    // Extract bone mass (kg)
    const boneMassMatch = text.match(/(?:massa [óo]ssea|bone mass)[:\s]+(\d+(?:\.\d+)?)\s*(?:kg)?/i);
    if (boneMassMatch) {
      data.boneMass = parseFloat(boneMassMatch[1]);
    }
  
    // Extract body water percentage
    const bodyWaterMatch = text.match(/(?:[áa]gua corporal|body water|%\s*[áa]gua)[:\s]+(\d+(?:\.\d+)?)\s*%?/i);
    if (bodyWaterMatch) {
      data.bodyWaterPercentage = parseFloat(bodyWaterMatch[1]);
    }
  
    // Extract visceral fat
    const visceralFatMatch = text.match(/(?:gordura visceral|visceral fat)[:\s]+(\d+(?:\.\d+)?)/i);
    if (visceralFatMatch) {
      data.visceralFat = parseFloat(visceralFatMatch[1]);
    }
  
    // Extract BMR (Basal Metabolic Rate)
    const bmrMatch = text.match(/(?:taxa metab[óo]lica basal|bmr|tmb)[:\s]+(\d+(?:\.\d+)?)\s*(?:kcal)?/i);
    if (bmrMatch) {
      data.bmr = parseFloat(bmrMatch[1]);
    }
  
    // Calculate or extract BMI
    const bmiMatch = text.match(/(?:imc|bmi)[:\s]+(\d+(?:\.\d+)?)/i);
    if (bmiMatch) {
      data.bmi = parseFloat(bmiMatch[1]);
    } else if (data.weight && data.height) {
      // Calculate BMI if not found: BMI = weight(kg) / (height(m))^2
      const heightInMeters = data.height / 100;
      data.bmi = parseFloat((data.weight / (heightInMeters * heightInMeters)).toFixed(2));
    }
  
    logger.debug('Extracted bioimpedance data', data);
    return data;
  }

• src/types/index.ts:63-72 (schema)

  TypeScript interface defining the structure of bioimpedance analysis data returned by the tool.

  export interface BioimpedanceData {
    patientName?: string;
    date?: string;
    weight?: number;
    height?: number;
    bodyFatPercentage?: number;
    muscleMassPercentage?: number;
    boneMass?: number;
    bodyWaterPercentage?: number;
    visceralFat?: number;