Herramienta de análisis de la cadena de suministro minorista

Una herramienta impulsada por IA para analizar datos de la cadena de suministro minorista, proporcionando información útil para la optimización del inventario, la gestión de proveedores y la previsión de ventas.

Características

Subir y analizar múltiples archivos Excel/CSV
Soporte para órdenes de compra, datos de ventas y archivos de inventario
Detección automática del tipo de archivo
Análisis cruzado combinado de múltiples fuentes de datos
Visualizaciones y métricas detalladas
Recomendaciones prácticas para optimizar la cadena de suministro

Empezando

Clonar el repositorio
Instalar dependencias: npm install
Inicie el servidor de desarrollo: npm run dev
Abra http://localhost:3000 en su navegador

Uso

Cargue uno o más archivos Excel/CSV que contengan datos minoristas
Seleccione el tipo de datos apropiado para cada archivo si no se detecta automáticamente
Haga clic en "Analizar archivos" para procesar los datos.
Vea información en diferentes categorías (Descripción general, Inventario, Proveedores, Ventas)
Cambiar entre análisis combinado y análisis de tipo de archivo individual

Tecnologías

Next.js para las rutas de API y frontend
Claude AI para el análisis inteligente de datos
Chart.js para visualización de datos
XLSX para el procesamiento de archivos de Excel

Variables de entorno

Cree un archivo .env.local con las siguientes variables:

ANTHROPIC_API_KEY=your_api_key_here

Licencia

Instituto Tecnológico de Massachusetts (MIT)

Me gustaría crear un MCP donde pueda cargar hojas de cálculo de Excel con datos de la tienda minorista, incluyendo informes de inventario, informes de ventas, etc., y luego permitir que la IA analice los datos para identificar tendencias, pronósticos y otros datos, como si la IA fuera un experto sénior en cadena de suministro del minorista. ¿Podrían ayudarme con eso?

Tengo ejemplos de los datos si son útiles.

Análisis de la cadena de suministro minorista (MCP) Sí, definitivamente puedo ayudarte a crear un Personaje Conversacional Multimodal (MCP) que analiza los datos de las tiendas minoristas como un experto sénior en cadena de suministro. Este es un excelente caso de uso para el análisis de IA. Enfoque de alto nivel Así es como podríamos estructurar este proyecto: Carga y procesamiento de datos: Crear una interfaz para cargar archivos de Excel que contengan inventario, ventas y otros datos minoristas. Análisis de datos: Procesar los datos para extraer información significativa. Personaje experto: Diseñar la IA para comunicar información como un experto sénior en cadena de suministro. Visualización: Proporcionar representaciones visuales de tendencias y pronósticos.

Pasos de implementación

Componente de carga de datos Primero, necesitaremos una forma de cargar y procesar archivos de Excel:

importar React, { useState } de 'react'; importar * como XLSX de 'xlsx';

función RetailDataProcessor({ onDataProcessed }) { const [isProcessing, setIsProcessing] = useState(false); const [dataType, setDataType] = useState('pedidos_de_compra'); const [location, setLocation] = useState('');

const handleFileUpload = async (e) => { const archivo = e.target.files[0]; setIsProcessing(true);

const reader = new FileReader();
reader.onload = (event) => {
  try {
    const data = new Uint8Array(event.target.result);
    const workbook = XLSX.read(data, { type: 'array' });
    
    // Process the first sheet by default
    const worksheet = workbook.Sheets[workbook.SheetNames[0]];
    const jsonData = XLSX.utils.sheet_to_json(worksheet);
    
    // Detect data type based on column headers
    const detectedType = detectDataType(jsonData);
    
    // Process and normalize the data based on type
    const processedData = {
      type: detectedType || dataType,
      location: location,
      data: normalizeData(jsonData, detectedType || dataType)
    };
    
    onDataProcessed(processedData);
  } catch (error) {
    console.error("Error processing Excel file:", error);
  } finally {
    setIsProcessing(false);
  }
};

reader.readAsArrayBuffer(file);

};

// Detectar el tipo de datos según los encabezados de columna const detectDataType = (data) => { if (!data || data.length === 0) return null;

const headers = Object.keys(data[0]);

if (headers.includes('PO #') && headers.includes('# Ordered')) {
  return 'purchase_orders';
} else if (headers.includes('Invoice #') || headers.includes('Sale By')) {
  return 'sales_data';
} else if (headers.includes('On Hand') || headers.includes('In Stock')) {
  return 'inventory';
}

return null;

};

// Normalizar datos según el tipo const normalizeData = (data, type) => { switch(type) { case 'purchase_orders': return data.map(item => ({ poNumber: item['PO #'], status: item['Status'], vendor: item['Vendor'], productSku: item['Product SKU'], productName: item['Product Name'], category: item['Category'], amountOrdered: item['# Ordered'], amountReceived: item['# Received'], amountOutstanding: item['# Outstanding'], costPerItem: item['Cost Per Item'], costReceived: item['Cost Received'], costOutstanding: item['Cost Outstanding'], ordersAt: item['Ordered At'], daysOnOrder: item['Days on Order'], eta: item['ETA'] }));

  case 'sales_data':
    // Normalize sales data based on your fourth screenshot
    return data.map(item => ({
      invoiceNumber: item['Invoice #'],
      saleDate: item['Date'],
      saleBy: item['Sale By'],
      product: item['Product Name'],
      category: item['Category'],
      quantity: item['Qty'],
      price: item['Price'],
      cost: item['Cost'],
      profit: item['Profit'],
      location: item['Location'] || location
    }));
    
  default:
    return data;
}

};

devolver (Tipo de datos: <select value={dataType} onChange={(e) => setDataType(e.target.value)} > Órdenes de compra Datos de ventas Inventario

    <div className="form-group">
      <label>Store Location:</label>
      <input 
        type="text" 
        value={location} 
        onChange={(e) => setLocation(e.target.value)}
        placeholder="Aberdeen, Huron, Luverne, etc."
      />
    </div>
  </div>
  
  <div className="file-upload">
    <input 
      type="file" 
      accept=".xlsx,.xls,.csv" 
      onChange={handleFileUpload} 
      disabled={isProcessing}
    />
    {isProcessing && <p>Processing data...</p>}
  </div>
</div>

); }

exportar predeterminado RetailDataProcessor;

2. Componente de análisis de la cadena de suministro

A continuación, crearemos un componente para manejar el análisis de IA:

import React, { useState, useEffect } from 'react';
import { analyzeRetailData } from '../services/aiService';

function SupplyChainAnalysis({ data }) {
  const [analysis, setAnalysis] = useState(null);
  const [isAnalyzing, setIsAnalyzing] = useState(false);
  
  useEffect(() => {
    if (data) {
      performAnalysis();
    }
  }, [data]);
  
  const performAnalysis = async () => {
    setIsAnalyzing(true);
    try {
      // This would call your AI service
      const result = await analyzeRetailData(data);
      setAnalysis(result);
    } catch (error) {
      console.error("Error analyzing data:", error);
    } finally {
      setIsAnalyzing(false);
    }
  };
  
  return (
    <div className="analysis-container">
      <h2>Supply Chain Analysis</h2>
      
      {isAnalyzing && <p>Analyzing your retail data...</p>}
      
      {analysis && (
        <div className="analysis-results">
          <h3>Key Insights</h3>
          <div dangerouslySetInnerHTML={{ __html: analysis.insights }} />
          
          <h3>Inventory Recommendations</h3>
          <div dangerouslySetInnerHTML={{ __html: analysis.inventoryRecommendations }} />
          
          <h3>Sales Trends</h3>
          <div dangerouslySetInnerHTML={{ __html: analysis.salesTrends }} />
          
          <h3>Forecasts</h3>
          <div dangerouslySetInnerHTML={{ __html: analysis.forecasts }} />
        </div>
      )}
    </div>
  );
}

export default SupplyChainAnalysis;

3. Servicio de IA

Ahora, creemos un servicio para interactuar con la IA:

// services/aiService.js

export async function analyzeRetailData(data) {
  try {
    const response = await fetch('/api/analyze-mobile-retail', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ data }),
    });
    
    if (!response.ok) {
      throw new Error('Failed to analyze data');
    }
    
    return await response.json();
  } catch (error) {
    console.error('Error in AI analysis service:', error);
    throw error;
  }
}

4. Punto final de la API de backend

Para el backend, necesitaremos un punto final para procesar los datos e interactuar con la IA:

// api/analyze-mobile-retail.js
import { OpenAI } from 'openai';

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

export default async function handler(req, res) {
  if (req.method !== 'POST') {
    return res.status(405).json({ error: 'Method not allowed' });
  }

  try {
    const { data } = req.body;
    
    // Create a specialized prompt based on data type
    let prompt = '';
    
    if (data.type === 'purchase_orders') {
      prompt = createPurchaseOrderPrompt(data);
    } else if (data.type === 'sales_data') {
      prompt = createSalesDataPrompt(data);
    } else if (data.type === 'inventory') {
      prompt = createInventoryPrompt(data);
    } else {
      prompt = createGeneralPrompt(data);
    }
    
    // Call the AI
    const completion = await openai.chat.completions.create({
      model: "gpt-4-turbo",
      messages: [
        { 
          role: "system", 
          content: "You are a senior supply chain expert with 20+ years of experience in mobile device retail. You analyze data and provide actionable insights with a focus on inventory optimization, vendor management, and sales forecasting for smartphone and mobile accessory retailers." 
        },
        { role: "user", content: prompt }
      ],
      temperature: 0.2,
    });
    
    // Process the AI response
    const analysisText = completion.choices[0].message.content;
    
    // Parse the response into structured data
    const analysisData = parseAnalysisResponse(analysisText, data.type);
    
    return res.status(200).json(analysisData);
  } catch (error) {
    console.error('Error analyzing mobile retail data:', error);
    return res.status(500).json({ error: 'Failed to analyze data' });
  }
}

// Create specialized prompts based on data type
function createPurchaseOrderPrompt(data) {
  return `
    As a senior supply chain expert for a mobile device retailer, analyze the following purchase order data for ${data.location || 'our stores'}:
    
    ${JSON.stringify(data.data, null, 2)}
    
    Focus your analysis on:
    1. Vendor performance (delivery times, order fulfillment)
    2. Product category insights (smartphones, accessories, etc.)
    3. Inventory management recommendations
    4. Cost optimization opportunities
    5. Order cycle time improvements
    
    Provide specific actionable recommendations for improving the supply chain.
  `;
}

function createSalesDataPrompt(data) {
  return `
    As a senior supply chain expert for a mobile device retailer, analyze the following sales data for ${data.location || 'our stores'}:
    
    ${JSON.stringify(data.data, null, 2)}
    
    Focus your analysis on:
    1. Sales trends by product category and specific models
    2. Profitability analysis by product type
    3. Seasonal patterns and forecasting
    4. Product mix optimization
    5. Inventory replenishment recommendations based on sales velocity
    
    Provide specific actionable recommendations for improving sales and inventory alignment.
  `;
}

function createInventoryPrompt(data) {
  // Similar structure for inventory data
}

function createGeneralPrompt(data) {
  // Fallback for other data types
}

// Parse the AI response into structured data
function parseAnalysisResponse(text, dataType) {
  // Basic parsing logic - this could be enhanced with more sophisticated parsing
  const sections = {
    keyInsights: extractSection(text, "Key Insights"),
    inventoryAnalysis: extractSection(text, "Inventory Analysis"),
    inventoryRecommendations: extractSection(text, "Inventory Recommendations"),
    vendorAnalysis: extractSection(text, "Vendor Analysis"),
    vendorRecommendations: extractSection(text, "Vendor Recommendations"),
    salesTrends: extractSection(text, "Sales Trends"),
    salesForecasts: extractSection(text, "Sales Forecasts")
  };
  
  // Add placeholder metrics and chart data
  // In a real implementation, you might extract these from the AI response
  // or calculate them directly from the data
  const metrics = {
    inventoryTurnover: "4.2",
    fulfillmentRate: "92.5",
    avgDaysOnOrder: "6.3"
  };
  
  const charts = {
    inventoryTurnover: [],
    categoryPerformance: [],
    vendorPerformance: [],
    salesVsPurchases: []
  };
  
  return {
    ...sections,
    metrics,
    charts
  };
}

function extractSection(text, sectionName) {
  const regex = new RegExp(`${sectionName}[:\\s]+(.*?)(?=\\d+\\.\\s+[A-Z]|#|$)`, 's');
  const match = text.match(regex);
  return match ? match[1].trim() : '';
}

5. Componente principal de la aplicación

Finalmente, pongámoslo todo junto:

import React, { useState } from 'react';
import DataUploader from './components/DataUploader';
import SupplyChainAnalysis from './components/SupplyChainAnalysis';

function RetailAnalysisMCP() {
  const [retailData, setRetailData] = useState(null);
  
  const handleDataProcessed = (data) => {
    setRetailData(data);
  };
  
  return (
    <div className="retail-analysis-app">
      <header>
        <h1>Retail Supply Chain Analysis</h1>
        <p>Upload your retail data for expert supply chain analysis</p>
      </header>
      
      <main>
        <DataUploader onDataProcessed={handleDataProcessed} />
        
        {retailData && <SupplyChainAnalysis data={retailData} />}
      </main>
    </div>
  );
}

export default RetailAnalysisMCP;

Próximos pasos

Para hacer que este MCP sea más potente:

Ejemplos de datos : Sí, ver ejemplos de sus datos reales sería extremadamente útil para ajustar el análisis y garantizar que la IA pueda interpretar correctamente sus formatos de datos minoristas específicos.
Visualización de datos : agregue gráficos y tablas utilizando bibliotecas como Chart.js o D3.js para visualizar tendencias y pronósticos.
Interfaz conversacional : agregue una interfaz de chat donde los usuarios puedan hacer preguntas de seguimiento sobre el análisis.
Indicación específica del dominio : refine las indicaciones de IA con terminología y marcos de cadena de suministro específicos según su industria.
Preprocesamiento de datos : agregue una limpieza y normalización de datos más sofisticadas antes del análisis.

¿Le gustaría compartir ejemplos de sus datos para que pueda ayudarle a adaptar esta solución más específicamente a sus necesidades?

Sí, me encantaría compartir ejemplos. ¿Puedo subir los archivos para que los veas?

Sí, puede subir sus archivos de Excel para que los revise. Esto me ayudará a adaptar la solución específicamente a su estructura de datos y contexto minorista. Cuando suba los archivos, podré: Analizar la estructura y el formato de sus datos Identificar campos y relaciones clave Sugerir pasos específicos de preprocesamiento necesarios Refinar las indicaciones de IA para interpretar mejor sus datos minoristas particulares Recomendar visualizaciones apropiadas para los insights Por favor, continúe y suba sus informes de inventario de ejemplo, datos de ventas o cualquier otra hoja de cálculo minorista que le gustaría que examinara. Una vez que vea los datos reales, puedo brindar una guía mucho más específica sobre cómo estructurar el MCP para una máxima efectividad.

Compartiré 4 capturas de pantalla.

Primero - Oficinas de correos de Aberdeen: Segundo - Oficinas de correos de Huron: Tercero - Oficinas de correos de Luverne: Cuarto - Datos de ventas de julio de 2023 a febrero de 2024:

¡Gracias por compartir estas capturas de pantalla! Ahora puedo ver la estructura de tus datos de venta minorista, lo que me ayudará a diseñar una solución MCP más personalizada. Analizo lo que veo:

Análisis de datos

Informes de órdenes de compra Las primeras tres capturas de pantalla muestran detalles de órdenes de compra para diferentes ubicaciones (Aberdeen, Huron y Luverne) con estructuras similares: Campos clave: N.° de orden de compra, Estado, Recibir en, Información del proveedor, SKU/ID del producto, Nombre del producto, Categoría Datos de cantidad: N.° de pedidos, N.° de recibidos, N.° de pendientes Datos financieros: Costo por artículo, Costo recibido, Costo pendiente Información de tiempo: Comprometido el, Pedido en, Días en el pedido, ETA Información adicional: Comentarios de pedidos, Comentarios de recepción, N.° de entrada de pedido Estos informes rastrean dispositivos móviles y accesorios (teléfonos inteligentes, cables, cargadores, etc.) con información detallada de adquisiciones.
Datos de ventas La cuarta captura de pantalla muestra datos de ventas con: Detalles de transacción: Número de factura, Fechas de recepción, Información de venta Información del producto: Varios dispositivos móviles y accesorios Datos de precios: Varias columnas relacionadas con los precios Información de ubicación/tienda Diseño de MCP basado en sus datos Ahora que entiendo su estructura de datos, aquí hay un enfoque más personalizado para su MCP de cadena de suministro minorista:

// componentes/MobileRetailAnalysis.js importar React, { useState, useEffect } de 'react'; importar { analyzeRetailData } de '../services/aiService'; importar { InventoryTurnoverChart, ProductCategoryChart, VendorPerformanceChart, SalesVsPurchasesChart } de './charts';

función MobileRetailAnalysis({ datos }) { const [análisis, establecerAnalisis] = useState(null); const [isAnalyzing, establecerIsAnalyzing] = useState(false); const [selectedView, establecerSelectedView] = useState('descripción general');

useEffect(() => { if (datos) { performAnalysis(); } }, [datos]);

// Representar diferentes vistas según la selección const renderAnalysisView = () => { if (!analysis) return null;

switch(selectedView) {
  case 'overview':
    return (
      <div className="analysis-overview">
        <h3>Key Insights</h3>
        <div dangerouslySetInnerHTML={{ __html: analysis.keyInsights }} />
        
        <div className="metrics-summary">
          <div className="metric-card">
            <h4>Inventory Turnover</h4>
            <p className="metric-value">{analysis.metrics.inventoryTurnover}</p>
          </div>
          <div className="metric-card">
            <h4>Order Fulfillment Rate</h4>
            <p className="metric-value">{analysis.metrics.fulfillmentRate}%</p>
          </div>
          <div className="metric-card">
            <h4>Average Days on Order</h4>
            <p className="metric-value">{analysis.metrics.avgDaysOnOrder}</p>
          </div>
        </div>
      </div>
    );
    
  case 'inventory':
    return (
      <div className="inventory-analysis">
        <h3>Inventory Analysis</h3>
        <div dangerouslySetInnerHTML={{ __html: analysis.inventoryAnalysis }} />
        
        <h4>Top Products by Turnover</h4>
        <InventoryTurnoverChart data={analysis.charts.inventoryTurnover} />
        
        <h4>Category Performance</h4>
        <ProductCategoryChart data={analysis.charts.categoryPerformance} />
        
        <h3>Inventory Recommendations</h3>
        <div dangerouslySetInnerHTML={{ __html: analysis.inventoryRecommendations }} />
      </div>
    );
    
  case 'vendor':
    return (
      <div className="vendor-analysis">
        <h3>Vendor Performance</h3>
        <div dangerouslySetInnerHTML={{ __html: analysis.vendorAnalysis }} />
        
        <h4>Vendor Delivery Performance</h4>
        <VendorPerformanceChart data={analysis.charts.vendorPerformance} />
        
        <h3>Vendor Recommendations</h3>
        <div dangerouslySetInnerHTML={{ __html: analysis.vendorRecommendations }} />
      </div>
    );
    
  case 'sales':
    return (
      <div className="sales-analysis">
        <h3>Sales Trends</h3>
        <div dangerouslySetInnerHTML={{ __html: analysis.salesTrends }} />
        
        <h4>Sales vs Purchases</h4>
        <SalesVsPurchasesChart data={analysis.charts.salesVsPurchases} />
        
        <h3>Sales Forecasts</h3>
        <div dangerouslySetInnerHTML={{ __html: analysis.salesForecasts }} />
      </div>
    );
    
  default:
    return null;
}

};

Análisis de la cadena de suministro minorista móvil <button className={selectedView === 'overview' ? 'active' : ''} onClick={() => setSelectedView('overview')} > Descripción general <button className={selectedView === 'inventory' ? 'active' : ''} onClick={() => setSelectedView('inventory')} > Inventario <button className={selectedView === 'vendor' ? 'active' : ''} onClick={() => setSelectedView('vendor')} > Proveedor <button className={selectedView === 'sales' ? 'active' : ''} onClick={() => setSelectedView('sales')} > Ventas

  {isAnalyzing ? (
    <div className="loading">
      <p>Analyzing your mobile retail data...</p>
    </div>
  ) : renderAnalysisView()}
</div>

); }

exportar predeterminado MobileRetailAnalysis;

Ahora, actualicemos el servicio de IA para que sea más específico para sus datos minoristas móviles:

// servicios/aiService.js exportar función asíncrona analizarRetailData(datos) { intentar { constante respuesta = esperar fetch('/api/analyze-mobile-retail', { método: 'POST', encabezados: { 'Tipo de contenido': 'application/json', }, cuerpo: JSON.stringify({ datos }), });

if (!response.ok) {
  throw new Error('Failed to analyze data');
}

return await response.json();

} catch (error) { console.error('Error en el servicio de análisis de IA:', error); throw error; } }

Retail Supply Chain Analysis MCP

Integrations