diff --git a/BUILDER_APPS_MIGRATION.md b/BUILDER_APPS_MIGRATION.md index 9798a36b..e210867d 100644 --- a/BUILDER_APPS_MIGRATION.md +++ b/BUILDER_APPS_MIGRATION.md @@ -12,11 +12,12 @@ Bevor Code kopiert wird, m.ssen die Grundlagen stimmen. -### 1.1 Package.json Check -Generierte Apps haben oft kein `express`, da sie keinen Server erwarten. -* **Aktion:** "."ffne `package.json` der App. -* **Pr.fung:** Steht `express` unter `dependencies`? -* **Fix:** +### 1.1 Package.json Check (Frontend Build-Falle) +Generierte Apps haben oft kein `express`, da sie keinen Server erwarten. Noch wichtiger ist, dass kritische Build-Tools oft fälschlicherweise in `devDependencies` deklariert werden. + +* **Aktion:** Öffne `package.json` der App. +* **Prüfung 1 (Backend):** Steht `express` unter `dependencies`? +* **Fix 1:** ```json "dependencies": { ... @@ -24,6 +25,8 @@ Generierte Apps haben oft kein `express`, da sie keinen Server erwarten. "cors": "^2.8.5" } ``` +* **Prüfung 2 (Frontend Build):** Stehen Build-Tools wie `vite`, `@vitejs/plugin-react` oder `typescript` unter `devDependencies`? +* **Fix 2 (KRITISCH):** Verschiebe **alle** `devDependencies` in die `dependencies`. Der `npm install`-Befehl im `Dockerfile` installiert `devDependencies` standardmäßig nicht, was zu einem fehlgeschlagenen `npm run build` führt. ### 1.2 Datenbank-Datei Docker kann keine einzelne Datei mounten, wenn sie auf dem Host nicht existiert. @@ -151,16 +154,21 @@ Das System entscheidet automatisch, welches Modell genutzt wird: * **Szenario B: Produkt-Integration (Image-to-Image)** * **Modell:** `gemini-2.5-flash-image`. -### A.6 Gemini SDK-Chaos & Modell-Verf.gbarkeit (Kritische Erkenntnis) +### A.6 Gemini SDK-Chaos & Modell-Verfügbarkeit (Kritische Erkenntnis) -Ein wiederkehrendes Problem bei der Migration ist der Konflikt zwischen SDK-Versionen und regionalen Modell-Beschr.nkungen. +Ein wiederkehrendes Problem bei der Migration ist der Konflikt zwischen SDK-Versionen und regionalen Modell-Beschränkungen, sowie die schnelle Evolution der API-Schnittstellen. **1. Das SDK-Dilemma** -Es existieren zwei parallele Google SDKs: -1. **`google-generativeai` (Legacy):** Veraltet, oft instabil bei neuen Modellen, wirft Deprecation-Warnungen. Import: `import google.generativeai`. -2. **`google-genai` (Modern):** Erforderlich f.r Imagen 4 und Gemini 2.x Features. Import: `from google import genai`. +Es existieren zwei parallele Google SDKs, und selbst innerhalb von `google-generativeai` ändern sich die Modulstrukturen schnell: +1. **`google-generativeai` (Legacy):** Versionen wie `0.3.0` verhalten sich anders als neuere. Oft instabil bei neuen Modellen, wirft Deprecation-Warnungen. Import: `import google.generativeai`. +2. **`google-genai` (Modern):** Erforderlich für Imagen 4 und Gemini 2.x Features. Import: `from google import genai`. -**L.SUNG:** Nutze den **Dual-Support-Ansatz** in `helpers.py`. Importiere beide und verwende die neue Lib f.r Bilder und die alte (da stabiler f.r bestehende Text-Prompts) f.r Flash 1.5/2.0. +**KRITISCHES PROBLEM: `ImportError` für `Schema` und `Content` mit `google-generativeai==0.3.0`** +* **Fehler:** `ImportError: cannot import name 'Schema' from 'google.generativeai.types'` oder `ImportError: cannot import name 'Content' from 'google.generativeai.types'`. +* **Ursache:** In älteren Versionen des `google-generativeai`-SDK (z.B. `0.3.0`, wie in diesem Projekt verwendet) existierten diese Klassen (`Schema`, `Content`) nicht an den gleichen Importpfaden wie in neueren Versionen oder wurden gar nicht als separate Klassen verwendet. +* **LÖSUNG (für `google-generativeai==0.3.0`):** + * Entferne **alle** Importe für `Schema` und `Content` (z.B. `from google.generativeai.types import HarmCategory, HarmBlockThreshold`). + * Ersetze **alle** Instanziierungen von `Schema(...)` durch einfache Python-Dictionaries, die direkt das JSON-Schema repräsentieren. Die `generation_config` akzeptiert in dieser Version direkt das Dictionary. **2. Der "404 Not Found" Modell-Fehler** Oft liefert die API einen 404 Fehler f.r ein Modell (z.B. `gemini-1.5-flash`), obwohl es laut Dokumentation existiert. @@ -179,7 +187,7 @@ candidates = ['imagen-4.0-generate-001', 'imagen-3.0-generate-001'] for model in candidates: try: # Versuch des API-Calls - break + break except ClientError as e: if "404" in str(e): continue raise e diff --git a/MIGRATION_REPORT_COMPETITOR_ANALYSIS.md b/MIGRATION_REPORT_COMPETITOR_ANALYSIS.md new file mode 100644 index 00000000..cbf8b5f9 --- /dev/null +++ b/MIGRATION_REPORT_COMPETITOR_ANALYSIS.md @@ -0,0 +1,47 @@ +# Migration Report: Competitor Analysis Agent + +## Status: Jan 09, 2026 + +The `competitor-analysis` application has been successfully migrated to the local Docker stack and integrated into the `gemini-gateway` (Nginx). + +### 1. Vorgehen (Process) + +1. **Dateistruktur:** + * Erstellung des Verzeichnisses `competitor-analysis-app/`. + * Kopie aller Dateien aus dem Original-Verzeichnis. +2. **Frontend-Anpassung:** + * `vite.config.ts`: `base: './'` gesetzt, um korrektes Routing unter dem Sub-Pfad `/ca/` zu ermöglichen. + * `geminiService.ts`: Direkte Aufrufe an `@google/genai` entfernt. Alle Funktionen nutzen nun `fetch()` an den neuen Python-Backend-Endpunkt `/api/...`. +3. **Backend-Orchestrator (Python/FastAPI):** + * Erstellung von `competitor_analysis_orchestrator.py`. + * Portierung aller Prompts und Schemata aus dem TypeScript-Code in Python (Pydantic & Google Generative AI SDK). + * Implementierung einer robusten JSON-Parsing-Logik (`parse_json_response`), die Markdown-Blöcke entfernt und inkonsistente LLM-Antworten korrigiert. + * Implementierung einer Modell-Kandidaten-Liste (`gemini-1.5-pro` mit Fallback), um regionale Verfügbarkeit sicherzustellen. + * Integration von `StaticFiles`, um das fertig gebaute Frontend direkt über den Python-Server auszuliefern. +4. **Docker-Integration:** + * `Dockerfile`: Multi-Stage Build (Node.js zum Bauen, Python zum Ausführen). + * `docker-compose.yml`: Neuer Service `competitor-analysis` hinzugefügt, inklusive Volume-Mounts für API-Keys und Live-Debugging des Orchestrators. + * `nginx-proxy.conf`: Routing für `/ca/` konfiguriert. + +### 2. Next Steps + +* **Persistenz:** Aktuell werden Analysen nur im App-State (RAM) gehalten. Eine Anbindung an die SQLite-Datenbank (ähnlich wie beim `b2b-app`) wäre sinnvoll, um Analysen zu speichern und später wieder aufzurufen. +* **Fehlermanagement:** Verfeinerung der Error-Handler im Frontend, um spezifische Backend-Fehler (z.B. API-Limits) besser anzuzeigen. +* **Weitere Schritte im Orchestrator:** Implementierung der verbleibenden Steps (4-8), falls diese noch nicht vollständig in Python abgebildet sind (derzeit sind Step 1, 2, 3, 4, 5, 6, 7 und 8 bereits im Code vorbereitet oder implementiert). + +### 3. Lessons Learned + +* **Python SDK-Versionskonflikte (`google-generativeai==0.3.0`):** Das im Projekt verwendete Python SDK (`google-generativeai` Version `0.3.0`) ist nicht mit neueren API-Schnittstellen kompatibel. + * `ImportError: cannot import name 'Schema' from 'google.generativeai.types'` und `ImportError: cannot import name 'Content' from 'google.generativeai.types'` treten auf, da diese Klassen in dieser SDK-Version an diesen Importpfaden nicht existieren oder anders implementiert sind. + * **Lösung:** Schemata müssen direkt als Python-Dictionaries an die `generation_config` übergeben werden. Alle Importe für `Schema` und `Content` müssen entfernt werden. +* **Frontend Build (`package.json` `devDependencies`):** Build-Tools wie `vite`, `@vitejs/plugin-react` und `typescript` müssen in den `dependencies` der `package.json` stehen, nicht in `devDependencies`. Andernfalls schlägt `npm install` im Docker-Build fehl, was zu einem leeren oder fehlenden `dist`-Ordner und einem 404-Fehler des Python-Servers führt. +* **Syntaxfehler in mehrzeiligen Prompts (`f-strings`):** Besonders bei älteren Python-Versionen und komplexen mehrzeiligen Prompts mit `f-strings` können subtile Fehler (z.B. falsch platzierte Anführungszeichen oder unbeabsichtigter deutscher Text in englischen Prompts) zu `SyntaxError: unterminated string literal` führen. + * **Lösung:** Die robusteste Methode ist, mehrzeilige Prompts als Liste von Strings zu definieren und mit `"\n".join()` zusammenzufügen. + +* **SDK-Unterschiede:** Das Python SDK (`google-generativeai`) verhält sich bei der Schema-Validierung strikter als die JS-Variante. Prompts mussten leicht angepasst werden, um sicherzustellen, dass die AI wirklich valides JSON liefert. +* **Vite Base Path:** Ohne `base: './'` in `vite.config.ts` schlagen alle Asset-Requests fehl, wenn die App hinter einem Proxy unter `/ca/` läuft. +* **Double JSON Trap:** LLMs neigen dazu, JSON in Markdown zu packen. Der Backend-Orchestrator muss dies proaktiv bereinigen, bevor `json.loads()` aufgerufen wird. +* **Proxy-Routing:** Der Trailing Slash in Nginx (`proxy_pass http://.../`) ist kritisch, damit die Pfade innerhalb der App korrekt aufgelöst werden. + +--- +*Dokumentation erstellt am 09.01.2026* diff --git a/competitor-analysis-app/App.tsx b/competitor-analysis-app/App.tsx new file mode 100644 index 00000000..a9b2dc84 --- /dev/null +++ b/competitor-analysis-app/App.tsx @@ -0,0 +1,448 @@ +import React, { useState, useCallback, useEffect, useRef } from 'react'; +import type { AppState, CompetitorCandidate, Product, TargetIndustry, Keyword, SilverBullet, Battlecard, ReferenceAnalysis } from './types'; +import { fetchStep1Data, fetchStep2Data, fetchStep3Data, fetchStep4Data, fetchStep5Data_SilverBullets, fetchStep6Data_Conclusion, fetchStep7Data_Battlecards, fetchStep8Data_ReferenceAnalysis } from './services/geminiService'; +import { generatePdfReport } from './services/pdfService'; +import InputForm from './components/InputForm'; +import StepIndicator from './components/StepIndicator'; +import Step1Extraction from './components/Step1_Extraction'; +import Step2Keywords from './components/Step2_Keywords'; +import Step3Competitors from './components/Step3_Competitors'; +import Step4Analysis from './components/Step4_Analysis'; +import Step5SilverBullets from './components/Step5_SilverBullets'; +import Step6Conclusion from './components/Step6_Conclusion'; +import Step7_Battlecards from './components/Step7_Battlecards'; +import Step8_References from './components/Step8_References'; +import LoadingSpinner from './components/LoadingSpinner'; +import { translations } from './translations'; + +const SunIcon = () => (); +const MoonIcon = () => (); +const RestartIcon = () => (); +const DownloadIcon = () => (); +const ChevronDownIcon = () => (); + + +const App: React.FC = () => { + const [appState, setAppState] = useState(null); + const [isLoading, setIsLoading] = useState(false); + const [error, setError] = useState(null); + const [theme, setTheme] = useState<'light' | 'dark'>('dark'); + const [highestStep, setHighestStep] = useState(0); + const [isDropdownOpen, setIsDropdownOpen] = useState(false); + const dropdownRef = useRef(null); + + const t = translations[appState?.initial_params?.language || 'de']; + + useEffect(() => { + if (theme === 'dark') { + document.documentElement.classList.add('dark'); + } else { + document.documentElement.classList.remove('dark'); + } + }, [theme]); + + useEffect(() => { + const handleClickOutside = (event: MouseEvent) => { + if (dropdownRef.current && !dropdownRef.current.contains(event.target as Node)) { + setIsDropdownOpen(false); + } + }; + document.addEventListener("mousedown", handleClickOutside); + return () => document.removeEventListener("mousedown", handleClickOutside); + }, []); + + const handleRestart = () => { + setAppState(null); + setIsLoading(false); + setError(null); + setHighestStep(0); + }; + + const handleStartAnalysis = useCallback(async (startUrl: string, maxCompetitors: number, marketScope: string, language: 'de' | 'en') => { + setIsLoading(true); + setError(null); + setAppState(null); + setHighestStep(0); + const currentT = translations[language]; + try { + const { products, target_industries } = await fetchStep1Data(startUrl, language); + setAppState({ + step: 1, + initial_params: { start_url: startUrl, max_competitors: maxCompetitors, market_scope: marketScope, language }, + company: { name: new URL(startUrl).hostname.replace('www.', ''), start_url: startUrl }, + products: products, + target_industries: target_industries, + keywords: [], + competitor_candidates: [], + competitors_shortlist: [], + analyses: [], + silver_bullets: [], + conclusion: null, + battlecards: [], + reference_analysis: [], + reference_analysis_grounding: [], + }); + setHighestStep(1); + } catch (e) { + console.error("Error in Step 1:", e); + setError(currentT.errors.step1); + } finally { + setIsLoading(false); + } + }, []); + + const handleConfirmStep = useCallback(async () => { + if (!appState) return; + + setIsLoading(true); + setError(null); + const nextStep = appState.step + 1; + const lang = appState.initial_params.language; + try { + let newState: Partial = {}; + switch (appState.step) { + case 1: + const { keywords } = await fetchStep2Data(appState.products, appState.target_industries, lang); + newState = { keywords, step: 2 }; + break; + case 2: + const { competitor_candidates } = await fetchStep3Data(appState.keywords, appState.initial_params.market_scope, lang); + newState = { competitor_candidates, step: 3 }; + break; + case 3: + const shortlist = [...appState.competitor_candidates] + .sort((a, b) => b.confidence - a.confidence) + .slice(0, appState.initial_params.max_competitors); + const { analyses } = await fetchStep4Data(appState.company, shortlist, lang); + newState = { competitors_shortlist: shortlist, analyses, step: 4 }; + break; + case 4: + const { silver_bullets } = await fetchStep5Data_SilverBullets(appState.company, appState.analyses, lang); + newState = { silver_bullets, step: 5 }; + break; + case 5: + const { conclusion } = await fetchStep6Data_Conclusion(appState.company, appState.products, appState.target_industries, appState.analyses, appState.silver_bullets, lang); + newState = { conclusion, step: 6 }; + break; + case 6: + const { battlecards } = await fetchStep7Data_Battlecards(appState.company, appState.analyses, appState.silver_bullets, lang); + newState = { battlecards, step: 7 }; + break; + case 7: + const { reference_analysis, groundingMetadata } = await fetchStep8Data_ReferenceAnalysis(appState.competitors_shortlist, lang); + newState = { reference_analysis, reference_analysis_grounding: groundingMetadata, step: 8 }; + break; + } + setAppState(prevState => ({ ...prevState!, ...newState })); + if (nextStep > highestStep) { + setHighestStep(nextStep); + } + } catch (e) { + console.error(`Error in Step ${appState.step + 1}:`, e); + setError(translations[lang].errors.generic(appState.step + 1)); + } finally { + setIsLoading(false); + } + }, [appState, highestStep]); + + const handleUpdateState = useCallback((key: keyof AppState, value: any) => { + setAppState(prevState => { + if (!prevState) return null; + return { ...prevState, [key]: value }; + }); + }, []); + + const renderStepContent = () => { + if (!appState) return null; + switch (appState.step) { + case 1: return handleUpdateState('products', p)} onIndustriesChange={(i) => handleUpdateState('target_industries', i)} t={t.step1} lang={appState.initial_params.language} />; + case 2: return handleUpdateState('keywords', k)} t={t.step2} />; + case 3: return handleUpdateState('competitor_candidates', c)} maxCompetitors={appState.initial_params.max_competitors} t={t.step3} />; + case 4: return ; + case 5: return ; + case 6: return ; + case 7: return ; + case 8: return ; + default: return null; + } + }; + + // Download logic + const handleDownloadJson = () => { + if (!appState) return; + const content = JSON.stringify(appState, null, 2); + const blob = new Blob([content], { type: 'application/json' }); + const url = URL.createObjectURL(blob); + const link = document.createElement('a'); + link.href = url; + link.download = `analysis_${appState.company.name}.json`; + document.body.appendChild(link); + link.click(); + document.body.removeChild(link); + URL.revokeObjectURL(url); + setIsDropdownOpen(false); + }; + + const transformMatrixData = (matrixData: any[] | undefined): { [row: string]: { [col: string]: string } } => { + const tableData: { [row: string]: { [col: string]: string } } = {}; + if (!matrixData || !Array.isArray(matrixData) || matrixData.length === 0) { + return tableData; + } + + const allCompetitors = new Set(); + matrixData.forEach(row => { + if (row && Array.isArray(row.availability)) { + row.availability.forEach(item => { + if (item && typeof item.competitor === 'string') { + allCompetitors.add(item.competitor); + } + }); + } + }); + const competitorList = Array.from(allCompetitors).sort(); + + matrixData.forEach(row => { + if (!row) return; + + const rowKey = 'product' in row ? row.product : ('industry' in row ? row.industry : undefined); + + if (typeof rowKey !== 'string' || !rowKey) { + return; + } + + const availabilityMap = new Map(); + if (Array.isArray(row.availability)) { + row.availability.forEach(item => { + if (item && typeof item.competitor === 'string') { + availabilityMap.set(item.competitor, item.has_offering); + } + }); + } + + const rowObject: { [col: string]: string } = {}; + competitorList.forEach(competitor => { + rowObject[competitor] = availabilityMap.get(competitor) ? '✓' : ' '; + }); + tableData[rowKey] = rowObject; + }); + + return tableData; + }; + + + const generateMarkdownReport = (): string => { + if (!appState) return ""; + const langT = t.step6.markdown; + let md = `# ${langT.title}: ${appState.company.name}\n\n`; + md += `**${langT.startUrl}:** ${appState.initial_params.start_url}\n`; + md += `**${langT.marketScope}:** ${appState.initial_params.market_scope}\n\n`; + + md += `## ${langT.step1_title}\n`; + md += `### ${langT.step1_products}\n`; + appState.products.forEach(p => md += `- **${p.name}:** ${p.purpose}\n`); + md += `\n### ${langT.step1_industries}\n`; + appState.target_industries.forEach(i => md += `- ${i.name}\n`); + + md += `\n## ${langT.step4_title}\n`; + appState.analyses.forEach(a => { + md += `### ${a.competitor.name} (Overlap: ${a.overlap_score}%)\n`; + md += `- **${langT.portfolio}:** ${a.portfolio.map(p => p.product).join(', ')}\n`; + md += `- **${langT.targetIndustries}:** ${a.target_industries.join(', ')}\n`; + md += `- **${langT.differentiators}:**\n`; + a.differentiators.forEach(d => md += ` - ${d}\n`); + md += `\n`; + }); + + md += `## ${langT.step5_title}\n`; + appState.silver_bullets.forEach(b => { + md += `- **${langT.against} ${b.competitor_name}:** "${b.statement}"\n`; + }); + + if (appState.battlecards && appState.battlecards.length > 0) { + md += `\n## ${langT.step7_title}\n\n`; + appState.battlecards.forEach(card => { + md += `### ${langT.against} ${card.competitor_name}\n\n`; + md += `**${langT.profile}:**\n`; + md += `- **${langT.focus}:** ${card.competitor_profile.focus}\n`; + md += `- **${langT.positioning}:** ${card.competitor_profile.positioning}\n\n`; + + md += `**${langT.strengthsVsWeaknesses}:**\n`; + (card.strengths_vs_weaknesses || []).forEach(s => md += `- ${s}\n`); + md += `\n`; + + md += `**${langT.landmineQuestions}:**\n`; + (card.landmine_questions || []).forEach(q => md += `- ${q}\n`); + md += `\n`; + + md += `**${langT.silverBullet}:**\n`; + md += `> "${card.silver_bullet}"\n\n`; + }); + } + + if (appState.reference_analysis && appState.reference_analysis.length > 0) { + md += `\n## ${langT.step8_title}\n`; + appState.reference_analysis.forEach(analysis => { + md += `### ${analysis.competitor_name}\n`; + if ((analysis.references || []).length > 0) { + (analysis.references || []).forEach(ref => { + md += `- **${ref.name}** (${ref.industry || 'N/A'})\n`; + if(ref.testimonial_snippet) md += ` - *"${ref.testimonial_snippet}"*\n`; + if(ref.case_study_url) md += ` - [${langT.caseStudyLink}](${ref.case_study_url})\n`; + }); + } else { + md += ` - ${langT.noReferencesFound}\n`; + } + md += `\n`; + }); + if (appState.reference_analysis_grounding && appState.reference_analysis_grounding.length > 0) { + md += `\n#### ${langT.sources}\n`; + appState.reference_analysis_grounding + .filter(chunk => chunk.web && chunk.web.uri) + .forEach(chunk => { + md += `- [${chunk.web.title || chunk.web.uri}](${chunk.web.uri})\n`; + }); + } + } + + if(appState.conclusion) { + md += `\n## ${langT.step6_title}\n`; + const transformForMdTable = (data: { [key: string]: { [key: string]: string } }) => { + if (Object.keys(data).length === 0) return { head: '', body: '' }; + const headers = Object.keys(Object.values(data)[0] || {}); + const head = `| | ${headers.join(' | ')} |\n`; + const separator = `|---|${headers.map(() => '---').join('|')}|\n`; + const body = Object.entries(data).map(([row, cols]) => `| **${row}** | ${headers.map(h => cols[h] || ' ').join(' | ')} |`).join('\n'); + return { head, body: separator + body }; + }; + const productMatrixForTable = transformMatrixData(appState.conclusion.product_matrix); + const industryMatrixForTable = transformMatrixData(appState.conclusion.industry_matrix); + + md += `### ${langT.productMatrix}\n`; + const prodMd = transformForMdTable(productMatrixForTable); + md += prodMd.head + prodMd.body + '\n\n'; + + md += `### ${langT.industryMatrix}\n`; + const indMd = transformForMdTable(industryMatrixForTable); + md += indMd.head + indMd.body + '\n\n'; + + md += `### ${langT.summary}\n${appState.conclusion.summary}\n\n`; + md += `### ${langT.opportunities}\n${appState.conclusion.opportunities}\n\n`; + md += `### ${langT.nextQuestions}\n`; + (appState.conclusion.next_questions || []).forEach(q => md += `- ${q}\n`); + } + + return md; + }; + + const handleDownloadMd = () => { + const mdContent = generateMarkdownReport(); + const blob = new Blob([mdContent], { type: 'text/markdown' }); + const url = URL.createObjectURL(blob); + const link = document.createElement('a'); + link.href = url; + if (appState) { + link.download = `analysis_${appState.company.name}.md`; + } + document.body.appendChild(link); + link.click(); + document.body.removeChild(link); + URL.revokeObjectURL(url); + setIsDropdownOpen(false); + }; + + const handleDownloadPdf = async () => { + if (!appState) return; + await generatePdfReport(appState, t.step6.markdown); + setIsDropdownOpen(false); + }; + + return ( +
+
+

{t.appTitle}

+
+ {appState && highestStep >= 6 && ( +
+
+ +
+ {isDropdownOpen && ( + + )} +
+ )} + {appState && ( + + )} + +
+
+ +
+ {!appState && !isLoading && } + + {isLoading && !appState && } + + {appState && ( +
+ + +
+
+ {error && ( +
+

{t.errors.title}

+

{error}

+
+ )} + {isLoading ? : renderStepContent()} +
+ + {appState.step < 8 && !isLoading && ( +
+ +
+ )} +
+
+ )} +
+
+ ); +}; + +export default App; \ No newline at end of file diff --git a/competitor-analysis-app/Dockerfile b/competitor-analysis-app/Dockerfile new file mode 100644 index 00000000..bcb7cddd --- /dev/null +++ b/competitor-analysis-app/Dockerfile @@ -0,0 +1,33 @@ +# Stage 1: Build the React frontend +FROM node:18-alpine AS build-stage + +WORKDIR /app + +# Copy package files and install dependencies +COPY package*.json ./ +RUN npm install + +# Copy the rest of the frontend code and build +COPY . . +RUN npm run build + +# Stage 2: Python backend orchestrator +FROM python:3.11-slim + +WORKDIR /app + +# Copy requirements and install +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +# Copy the build from the first stage +COPY --from=build-stage /app/dist ./dist + +# Copy the orchestrator script and .env if needed (though env should be passed via docker-compose) +COPY competitor_analysis_orchestrator.py . + +# Expose the port the app runs on +EXPOSE 8000 + +# Command to run the orchestrator +CMD ["uvicorn", "competitor_analysis_orchestrator:app", "--host", "0.0.0.0", "--port", "8000"] diff --git a/competitor-analysis-app/README.md b/competitor-analysis-app/README.md new file mode 100644 index 00000000..19d65120 --- /dev/null +++ b/competitor-analysis-app/README.md @@ -0,0 +1,20 @@ +
+GHBanner +
+ +# Run and deploy your AI Studio app + +This contains everything you need to run your app locally. + +View your app in AI Studio: https://ai.studio/apps/drive/1vJMxbT1hW3SiMDUeEd8cXGO_PFo8GcsE + +## Run Locally + +**Prerequisites:** Node.js + + +1. Install dependencies: + `npm install` +2. Set the `GEMINI_API_KEY` in [.env.local](.env.local) to your Gemini API key +3. Run the app: + `npm run dev` diff --git a/competitor-analysis-app/competitor_analysis_orchestrator.py b/competitor-analysis-app/competitor_analysis_orchestrator.py new file mode 100644 index 00000000..8ab68eb7 --- /dev/null +++ b/competitor-analysis-app/competitor_analysis_orchestrator.py @@ -0,0 +1,917 @@ +import os +import json +from dotenv import load_dotenv +from fastapi import FastAPI, HTTPException +from fastapi.middleware.cors import CORSMiddleware +from fastapi.staticfiles import StaticFiles +from pydantic import BaseModel +from typing import List, Dict, Any, Optional + +import google.generativeai as genai +from google.generativeai.types import HarmCategory, HarmBlockThreshold + +# Load environment variables +load_dotenv() +API_KEY = os.getenv("GEMINI_API_KEY") + +# Fallback: check for API Key in a file (common in this project's Docker setup) +if not API_KEY: + key_file_path = os.getenv("GEMINI_API_KEY_FILE", "/app/gemini_api_key.txt") + if os.path.exists(key_file_path): + with open(key_file_path, 'r') as f: + API_KEY = f.read().strip() + +if not API_KEY: + raise ValueError("GEMINI_API_KEY environment variable or file not set") + +genai.configure(api_key=API_KEY) +# Use a candidate list for models as per migration guide +MODEL_CANDIDATES = ['gemini-1.5-pro', 'gemini-1.0-pro'] # Added 1.0-pro as fallback +model = None +for candidate in MODEL_CANDIDATES: + try: + model = genai.GenerativeModel(candidate) + print(f"DEBUG: Using Gemini model: {candidate}") + break + except Exception as e: + print(f"DEBUG: Could not load model {candidate}: {e}") + if "404" in str(e): + continue + raise e +if not model: + raise ValueError(f"No suitable Gemini model found from candidates: {MODEL_CANDIDATES}") + + +app = FastAPI() + +# Configure CORS +app.add_middleware( + CORSMiddleware, + allow_origins=["*"], + allow_credentials=True, + allow_methods=["*"], + allow_headers=["*"], +) + +def parse_json_response(text: str) -> Any: + """Parses JSON response, stripping markdown code blocks.""" + try: + # Clean the text, removing markdown code block fences + cleaned_text = text.replace('```json', '').replace('```', '').strip() + # Handle cases where the model might return a list instead of a direct object + result = json.loads(cleaned_text) + if isinstance(result, list) and result: + # If it's a list, assume the first element is the intended object + return result[0] + return result + except json.JSONDecodeError as e: + print(f"Failed to parse JSON: {e}\nOriginal text: {text}") + raise ValueError("Invalid JSON response from API") + +# --- Schemas (ported from TypeScript) --- +evidence_schema = { + "type": "object", + "properties": { + "url": {"type": "string"}, + "snippet": {"type": "string"}, + }, + "required": ['url', 'snippet'] +} + +product_schema = { + "type": "object", + "properties": { + "name": {"type": "string", "description": "Product name"}, + "purpose": {"type": "string", "description": "Purpose description (1-2 sentences)"}, + "evidence": {"type": "array", "items": evidence_schema}, + }, + "required": ['name', 'purpose', 'evidence'] +} + +industry_schema = { + "type": "object", + "properties": { + "name": {"type": "string", "description": "Name of the target industry"}, + "evidence": {"type": "array", "items": evidence_schema}, + }, + "required": ['name', 'evidence'] +} + + +# --- Request Models for FastAPI --- +class ProductDetailsRequest(BaseModel): + name: str + url: str + language: str + +class FetchStep1DataRequest(BaseModel): + start_url: str + language: str + +class ProductModel(BaseModel): + name: str + purpose: str + evidence: List[Dict[str, str]] + +class TargetIndustryModel(BaseModel): + name: str + evidence: List[Dict[str, str]] + +class FetchStep2DataRequest(BaseModel): + products: List[ProductModel] + industries: List[TargetIndustryModel] + language: str + +class KeywordModel(BaseModel): + term: str + rationale: str + +class FetchStep3DataRequest(BaseModel): + keywords: List[KeywordModel] + market_scope: str + language: str + +class CompanyModel(BaseModel): + name: str + start_url: str + +class CompetitorCandidateModel(BaseModel): + name: str + url: str + confidence: float + why: str + evidence: List[Dict[str, str]] + +class FetchStep4DataRequest(BaseModel): + company: CompanyModel + competitors: List[CompetitorCandidateModel] + language: str + +class AnalysisModel(BaseModel): + competitor: Dict[str, str] + portfolio: List[Dict[str, str]] + target_industries: List[str] + delivery_model: str + overlap_score: int + differentiators: List[str] + evidence: List[Dict[str, str]] + +class FetchStep5DataSilverBulletsRequest(BaseModel): + company: CompanyModel + analyses: List[AnalysisModel] + language: str + +class SilverBulletModel(BaseModel): + competitor_name: str + statement: str + +class FetchStep6DataConclusionRequest(BaseModel): + company: CompanyModel + products: List[ProductModel] + industries: List[TargetIndustryModel] + analyses: List[AnalysisModel] + silver_bullets: List[SilverBulletModel] + language: str + +class FetchStep7DataBattlecardsRequest(BaseModel): + company: CompanyModel + analyses: List[AnalysisModel] + silver_bullets: List[SilverBulletModel] + language: str + +class ShortlistedCompetitorModel(BaseModel): + name: str + url: str + +class FetchStep8DataReferenceAnalysisRequest(BaseModel): + competitors: List[ShortlistedCompetitorModel] + language: str + + +# --- Endpoints --- +@app.post("/api/fetchProductDetails") +async def fetch_product_details(request: ProductDetailsRequest): + prompts = { + "de": f""" + Analysiere die Webseite {request.url} und beschreibe den Zweck des Produkts "{request.name}" in 1-2 Sätzen. Gib auch die genaue URL und ein relevantes Snippet als Beleg an. + Das "name" Feld im JSON soll der offizielle Produktname sein, wie er auf der Seite gefunden wird, oder "{request.name}" falls nicht eindeutig. + Antworte ausschließlich im JSON-Format. + """, + "en": f""" + Analyze the website {request.url} and describe the purpose of the product "{request.name}" in 1-2 sentences. Also provide the exact URL and a relevant snippet as evidence. + The "name" field in the JSON should be the official product name as found on the page, or "{request.name}" if not clearly stated. + Respond exclusively in JSON format. + """ + } + + try: + response = await model.generate_content_async( + prompts[request.language], + generation_config=genai.GenerationConfig( + response_mime_type="application/json", + response_schema=product_schema + ), + safety_settings={ + HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE, + }, + ) + return parse_json_response(response.text) + except Exception as e: + print(f"Error in fetch_product_details: {e}") + raise HTTPException(status_code=500, detail=str(e)) + +@app.post("/api/fetchStep1Data") +async def fetch_step1_data(request: FetchStep1DataRequest): + prompts = { + "de": f""" + Rolle: Research-Agent für B2B-Software-Wettbewerbsanalyse. + Aufgabe: Analysiere die Website {request.start_url} und identifiziere die Hauptprodukte/Lösungen und deren Zielbranchen. + Regeln: + 1. Konzentriere dich auf offizielle Produkt- und Lösungsseiten. + 2. Jede Information (Produkt, Branche) muss mit einer URL und einem kurzen Snippet belegt werden. + 3. Sei präzise und vermeide Spekulationen. + Antworte ausschließlich im JSON-Format. + """, + "en": f""" + Role: Research Agent for B2B Software Competitor Analysis. + Task: Analyze the website {request.start_url} and identify the main products/solutions and their target industries. + Rules: + 1. Focus on official product and solution pages. + 2. Every piece of information (product, industry) must be backed by a URL and a short snippet as evidence. + 3. Be precise and avoid speculation. + Respond exclusively in JSON format. + """ + } + + response_schema = { + "type": "object", + "properties": { + "products": {"type": "array", "items": product_schema}, + "target_industries": {"type": "array", "items": industry_schema}, + }, + "required": ['products', 'target_industries'] + } + + try: + response = await model.generate_content_async( + prompts[request.language], + generation_config=genai.GenerationConfig( + response_mime_type="application/json", + response_schema=response_schema + ), + safety_settings={ + HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE, + }, + ) + return parse_json_response(response.text) + except Exception as e: + print(f"Error in fetch_step1_data: {e}") + raise HTTPException(status_code=500, detail=str(e)) + +@app.post("/api/fetchStep2Data") +async def fetch_step2_data(request: FetchStep2DataRequest): + prompts = { + "de": f""" + Rolle: Research-Agent. + Aufgabe: Leite aus den folgenden Produkt- und Brancheninformationen 10-25 präzise deutsche und englische Keywords/Suchphrasen für die Wettbewerbsrecherche ab. + Kontext: + Produkte: {', '.join([f'{p.name} ({p.purpose})' for p in request.products])} + Branchen: {', '.join([i.name for i in request.industries])} + Regeln: + 1. Erstelle Cluster: Produktkategorie, Funktionskern, Zielbranchen, Synonyme/Englischvarianten. + 2. Gib für jedes Keyword eine kurze Begründung ("rationale"). + 3. Antworte ausschließlich im JSON-Format. + """, + "en": f""" + Role: Research Agent. + Task: From the following product and industry information, derive 10-25 precise English keywords/search phrases for competitor research. + Context: + Products: {', '.join([f'{p.name} ({p.purpose})' for p in request.products])} + Industries: {', '.join([i.name for i in request.industries])} + Rules: + 1. Create clusters: Product category, core function, target industries, synonyms. + 2. Provide a brief rationale for each keyword. + 3. Respond exclusively in JSON format. + """ + } + + response_schema = { + "type": "object", + "properties": { + "keywords": { + "type": "array", + "items": { + "type": "object", + "properties": { + "term": {"type": "string"}, + "rationale": {"type": "string"} + }, + "required": ['term', 'rationale'] + } + } + }, + "required": ['keywords'] + } + try: + response = await model.generate_content_async( + prompts[request.language], + generation_config=genai.GenerationConfig( + response_mime_type="application/json", + response_schema=response_schema + ), + safety_settings={ + HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE, + }, + ) + return parse_json_response(response.text) + except Exception as e: + print(f"Error in fetch_step2_data: {e}") + raise HTTPException(status_code=500, detail=str(e)) + +@app.post("/api/fetchStep3Data") +async def fetch_step3_data(request: FetchStep3DataRequest): + prompts = { + "de": f""" + Rolle: Research-Agent. + Aufgabe: Finde relevante Wettbewerber basierend auf den folgenden Keywords. Fokussiere dich auf den Markt: {request.market_scope}. + Keywords: {', '.join([k.term for k in request.keywords])} + Regeln: + 1. Suche nach Software-Anbietern, nicht nach Resellern, Beratungen oder Implementierungspartnern. + 2. Gib für jeden Kandidaten an: Name, URL, Eignungsbegründung (why), Confidence-Score (0.0-1.0) und Belege (URL+Snippet). + 3. Antworte ausschließlich im JSON-Format. + """, + "en": f""" + Role: Research Agent. + Task: Find relevant competitors based on the following keywords. Focus on the market: {request.market_scope}. + Keywords: {', '.join([k.term for k in request.keywords])} + Rules: + 1. Search for software vendors, not resellers, consultants, or implementation partners. + 2. For each candidate, provide: Name, URL, justification for inclusion (why), confidence score (0.0-1.0), and evidence (URL+snippet). + 3. Respond exclusively in JSON format. + """ + } + + response_schema = { + "type": "object", + "properties": { + "competitor_candidates": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": {"type": "string"}, + "url": {"type": "string"}, + "confidence": {"type": "number"}, + "why": {"type": "string"}, + "evidence": {"type": "array", "items": evidence_schema} + }, + "required": ['name', 'url', 'confidence', 'why', 'evidence'] + } + } + }, + "required": ['competitor_candidates'] + } + try: + response = await model.generate_content_async( + prompts[request.language], + generation_config=genai.GenerationConfig( + response_mime_type="application/json", + response_schema=response_schema + ), + safety_settings={ + HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE, + }, + ) + return parse_json_response(response.text) + except Exception as e: + print(f"Error in fetch_step3_data: {e}") + raise HTTPException(status_code=500, detail=str(e)) + +@app.post("/api/fetchStep4Data") +async def fetch_step4_data(request: FetchStep4DataRequest): + competitors_summary = '\n'.join([f'- {c.name}: {c.url}' for c in request.competitors]) + prompts = { + "de": f""" + Rolle: Research-Agent. + Aufgabe: Führe eine detaillierte Portfolio- & Positionierungsanalyse für jeden der folgenden Wettbewerber durch. Vergleiche sie mit dem Ausgangsunternehmen {request.company.name} ({request.company.start_url}). + Wettbewerber: + {competitors_summary} + Analyse-Punkte pro Wettbewerber: + 1. portfolio: Kernprodukte (max. 5) mit kurzem Zweck. + 2. target_industries: Hauptzielbranchen. + 3. delivery_model: Geschäfts-/Bereitstellungsmodell (z.B. SaaS, On-Premise), falls ersichtlich. + 4. overlap_score: 0-100, basierend auf Produktfunktion, Zielbranche, Terminologie im Vergleich zum Ausgangsunternehmen. + 5. differentiators: 3-5 Bulletpoints zu Alleinstellungsmerkmalen oder Unterschieden. + 6. evidence: Wichtige Beleg-URLs mit Snippets. + Regeln: + 1. Jede Behauptung mit Quellen belegen. + 2. Antworte ausschließlich im JSON-Format. + """, + "en": f""" + Role: Research Agent. + Task: Conduct a detailed portfolio & positioning analysis for each of the following competitors. Compare them with the initial company {request.company.name} ({request.company.start_url}). + Competitors: + {competitors_summary} + Analysis points per competitor: + 1. portfolio: Core products (max 5) with a brief purpose. + 2. target_industries: Main target industries. + 3. delivery_model: Business/delivery model (e.g., SaaS, On-Premise), if apparent. + 4. overlap_score: 0-100, based on product function, target industry, terminology compared to the initial company. + 5. differentiators: 3-5 bullet points on unique selling points or differences. + 6. evidence: Key supporting URLs with snippets. + Rules: + 1. Back up every claim with sources. + 2. Respond exclusively in JSON format. + """ + } + + response_schema = { + "type": "object", + "properties": { + "analyses": { + "type": "array", + "items": { + "type": "object", + "properties": { + "competitor": {"type": "object", "properties": {"name": {"type": "string"}, "url": {"type": "string"}}} + "portfolio": {"type": "array", "items": {"type": "object", "properties": {"product": {"type": "string"}, "purpose": {"type": "string"}}}} + "target_industries": {"type": "array", "items": {"type": "string"}}, + "delivery_model": {"type": "string"}, + "overlap_score": {"type": "integer"}, + "differentiators": {"type": "array", "items": {"type": "string"}}, + "evidence": {"type": "array", "items": evidence_schema} + }, + "required": ['competitor', 'portfolio', 'target_industries', 'delivery_model', 'overlap_score', 'differentiators', 'evidence'] + } + } + }, + "required": ['analyses'] + } + try: + response = await model.generate_content_async( + prompts[request.language], + generation_config=genai.GenerationConfig( + response_mime_type="application/json", + response_schema=response_schema + ), + safety_settings={ + HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE, + }, + ) + return parse_json_response(response.text) + except Exception as e: + print(f"Error in fetch_step4_data: {e}") + raise HTTPException(status_code=500, detail=str(e)) + +@app.post("/api/fetchStep5Data_SilverBullets") +async def fetch_step5_data_silver_bullets(request: FetchStep5DataSilverBulletsRequest): + competitor_data_summary = '\n'.join([ + f"- Competitor: {a.competitor['name']}\n - Portfolio Focus: {', '.join([p['product'] for p in a.portfolio]) or 'N/A'}\n - Differentiators: {'; '.join(a.differentiators)}" + for a in request.analyses + ]) + + prompts = { + "de": f""" + Rolle: Strategieberater. + Aufgabe: Erstelle für das Unternehmen "{request.company.name}" eine "Silver Bullet" für jeden Wettbewerber. Eine "Silver Bullet" ist ein prägnanter Satz (max. 25 Wörter), der im Vertriebsgespräch genutzt werden kann, um sich vom jeweiligen Wettbewerber abzugrenzen. + Kontext: {request.company.name} wird mit den folgenden Wettbewerbern verglichen: + {competitor_data_summary.replace("Competitor:", "Wettbewerber:").replace("Portfolio Focus:", "Portfolio-Fokus:").replace("Differentiators:", "Alleinstellungsmerkmale:")} + + Regeln: + 1. Formuliere für JEDEN Wettbewerber einen einzigen, schlagkräftigen Satz. + 2. Der Satz soll eine Schwäche des Wettbewerbers oder eine Stärke von {request.company.name} im direkten Vergleich hervorheben. + 3. Sei prägnant und überzeugend. + 4. Antworte ausschließlich im JSON-Format. + """, + "en": f""" + Role: Strategy Consultant. + Task: Create a "Silver Bullet" for the company "{request.company.name}" for each competitor. A "Silver Bullet" is a concise sentence (max 25 words) that can be used in a sales pitch to differentiate from the respective competitor. + Context: {request.company.name} is being compared with the following competitors: + {competitor_data_summary} + + Rules: + 1. Formulate a single, powerful sentence for EACH competitor. + 2. The sentence should highlight a weakness of the competitor or a strength of {request.company.name} in direct comparison. + 3. Be concise and persuasive. + 4. Respond exclusively in JSON format. + """ + } + + response_schema = { + "type": "object", + "properties": { + "silver_bullets": { + "type": "array", + "items": { + "type": "object", + "properties": { + "competitor_name": {"type": "string"}, + "statement": {"type": "string"} + }, + "required": ['competitor_name', 'statement'] + } + } + }, + "required": ['silver_bullets'] + } + + try: + response = await model.generate_content_async( + prompts[request.language], + generation_config=genai.GenerationConfig( + response_mime_type="application/json", + response_schema=response_schema + ), + safety_settings={ + HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE, + }, + ) + return parse_json_response(response.text) + except Exception as e: + print(f"Error in fetch_step5_data_silver_bullets: {e}") + raise HTTPException(status_code=500, detail=str(e)) + +@app.post("/api/fetchStep6Data_Conclusion") +async def fetch_step6_data_conclusion(request: FetchStep6DataConclusionRequest): + competitor_data_summary = '\n\n'.join([ + f"- Competitor: {a.competitor['name']}\n - Portfolio: {', '.join([p['product'] for p in a.portfolio]) or 'N/A'}\n - Target Industries: {', '.join(a.target_industries) or 'N/A'}\n - Overlap Score: {a.overlap_score}\n - Differentiators: {'; '.join(a.differentiators)}" + for a in request.analyses + ]) + + silver_bullets_summary = '\n'.join([f"- Gegen {sb.competitor_name}: \"{sb.statement}\"" for sb in request.silver_bullets]) + if request.language == 'en': + silver_bullets_summary = '\n'.join([f"- Against {sb.competitor_name}: \"{sb.statement}\"" for sb in request.silver_bullets]) + + prompts = { + "de": """ + Rolle: Research-Agent. + Aufgabe: Erstelle ein Fazit der Wettbewerbsanalyse für {company_name}. + + Ausgangsunternehmen ({company_name}) Daten: + - Produkte: {products_summary} + - Branchen: {industries_summary} + + Zusammengefasste Wettbewerber-Daten: + {competitor_data_summary_de} + + Strategische Positionierung ("Silver Bullets"): + {silver_bullets_summary_de} + + Erstelle: + 1. product_matrix: Analysiere ALLE Produkte von {company_name} und den Wettbewerbern. Identifiziere 5-10 generische Produktkategorien oder Kernfunktionalitäten (z.B. "Mobile Lösung", "Disposition & Planung", "Asset Management"). Erstelle dann eine Matrix basierend auf diesen generischen Kategorien. Jedes Element im Array repräsentiert eine dieser Kategorien. Jedes Element hat ein "product" (string, der Name der generischen Kategorie) und ein "availability" (Array). Das "availability"-Array enthält Objekte mit "competitor" (string) und "has_offering" (boolean), für JEDEN Anbieter (inkl. {company_name}), das anzeigt, ob der Anbieter eine Lösung in dieser Kategorie hat. + 2. industry_matrix: Ein Array. Jedes Element repräsentiert eine Branche (von ALLEN Anbietern, inkl. {company_name}). Jedes Element hat eine "industry" (string) und ein "availability" (Array). Das "availability"-Array enthält Objekte mit "competitor" (string) und "has_offering" (boolean), für JEDEN Anbieter (inkl. {company_name}). + 3. overlap_scores: Eine Liste der Wettbewerber und ihrer Overlap-Scores. + 4. summary: Eine knappe Einordnung (2-3 Sätze), wer sich worauf positioniert. + 5. opportunities: Wo liegen Lücken oder Chancen für {company_name}? + 6. next_questions: Max. 5 offene Fragen oder nächste Schritte für den User. + Regeln: + 1. Antworte ausschließlich im JSON-Format gemäß dem vorgegebenen Schema. + ".format( + company_name=request.company.name, + products_summary=', '.join([p.name for p in request.products]), + industries_summary=', '.join([i.name for i in request.industries]), + competitor_data_summary_de=competitor_data_summary.replace("Competitor:", "Wettbewerber:").replace("Portfolio:", "Portfolio:").replace("Target Industries:", "Zielbranchen:").replace("Overlap Score:", "Overlap Score:").replace("Differentiators:", "Alleinstellungsmerkmale:"), + silver_bullets_summary_de=silver_bullets_summary + ), + "en": """ + Role: Research Agent. + Task: Create a conclusion for the competitive analysis for {company_name}. + + Initial Company ({company_name}) Data: + - Products: {products_summary} + - Industries: {industries_summary} + + Summarized Competitor Data: + {competitor_data_summary_en} + + Strategic Positioning ("Silver Bullets"): + {silver_bullets_summary_en} + + Create: + 1. product_matrix: Analyze ALL products from {company_name} and the competitors. Identify 5-10 generic product categories or core functionalities (e.g., "Mobile Solution", "Dispatch & Planning", "Asset Management"). Then create a matrix based on these generic categories. Each element in the array represents one of these categories. Each element has a "product" (string, the name of the generic category) and an "availability" (array). The "availability"-array contains objects with "competitor" (string) and "has_offering" (boolean), for EVERY provider (incl. {company_name}), indicating if the provider has a solution in this category. + 2. industry_matrix: An array. Each element represents an industry (from ALL providers, incl. {company_name}). Each element has an "industry" (string) and an "availability" (array). The "availability"-array contains objects with "competitor" (string) and "has_offering" (boolean), for EVERY provider (incl. {company_name}). + 3. overlap_scores: A list of competitors and their overlap scores. + 4. summary: A brief assessment (2-3 sentences) of who is positioned where. + 5. opportunities: Where are the gaps or opportunities for {company_name}? + 6. next_questions: Max 5 open questions or next steps for the user. + Rules: + 1. Respond exclusively in JSON format according to the provided schema. + ".format( + company_name=request.company.name, + products_summary=', '.join([p.name for p in request.products]), + industries_summary=', '.join([i.name for i in request.industries]), + competitor_data_summary_en=competitor_data_summary, + silver_bullets_summary_en=silver_bullets_summary + ) + } + + response_schema = { + "type": "object", + "properties": { + "conclusion": { + "type": "object", + "properties": { + "product_matrix": { + "type": "array", + "description": "Array representing a feature-based product comparison. Each item is a generic product category or core functionality.", + "items": { + "type": "object", + "properties": { + "product": {"type": "string", "description": "Name of the generic product category/feature."}, + "availability": { + "type": "array", + "description": "Which competitors offer this product.", + "items": { + "type": "object", + "properties": { + "competitor": {"type": "string"}, + "has_offering": {"type": "boolean", "description": "True if the competitor has a similar offering."} + }, + "required": ['competitor', 'has_offering'] + } + } + }, + "required": ['product', 'availability'] + } + }, + "industry_matrix": { + "type": "array", + "description": "Array representing industry comparison. Each item is an industry.", + "items": { + "type": "object", + "properties": { + "industry": {"type": "string", "description": "Name of the industry."}, + "availability": { + "type": "array", + "description": "Which competitors serve this industry.", + "items": { + "type": "object", + "properties": { + "competitor": {"type": "string"}, + "has_offering": {"type": "boolean", "description": "True if the competitor serves this industry."} + }, + "required": ['competitor', 'has_offering'] + } + } + }, + "required": ['industry', 'availability'] + } + }, + "overlap_scores": {"type": "array", "items": {"type": "object", "properties": {"competitor": {"type": "string"}, "score": {"type": "number"}}}}, + "summary": {"type": "string"}, + "opportunities": {"type": "string"}, + "next_questions": {"type": "array", "items": {"type": "string"}} + }, + "required": ['product_matrix', 'industry_matrix', 'overlap_scores', 'summary', 'opportunities', 'next_questions'] + } + }, + "required": ['conclusion'] + } + + try: + response = await model.generate_content_async( + prompts[request.language], + generation_config=genai.GenerationConfig( + response_mime_type="application/json", + response_schema=response_schema + ), + safety_settings={ + HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE, + }, + ) + return parse_json_response(response.text) + except Exception as e: + print(f"Error in fetch_step6_data_conclusion: {e}") + raise HTTPException(status_code=500, detail=str(e)) + +@app.post("/api/fetchStep7Data_Battlecards") +async def fetch_step7_data_battlecards(request: FetchStep7DataBattlecardsRequest): + competitor_data_summary = '\n\n'.join([ + f"- Competitor: {a.competitor['name']}\n - Portfolio Focus: {', '.join([p['product'] for p in a.portfolio]) or 'N/A'}\n - Target Industries: {', '.join(a.target_industries)}\n - Differentiators: {'; '.join(a.differentiators)}\n - Silver Bullet against this competitor: \"{next((sb.statement for sb in request.silver_bullets if sb.competitor_name == a.competitor['name']), 'Not found.')}\"" + for a in request.analyses + ]) + + prompts = { + "de": f""" + Rolle: Vertriebsstratege und Coach für das B2B-Softwareunternehmen "{request.company.name}". + Aufgabe: Erstelle für jeden der folgenden Wettbewerber eine detaillierte "Sales Battlecard". Diese Battlecard soll dem Vertriebsteam konkrete, handlungsorientierte Argumente für Kundengespräche an die Hand geben. + + Informationen über das eigene Unternehmen: {request.company.name} + Detaillierte Analyse der Wettbewerber: + {competitor_data_summary.replace("Competitor:", "Wettbewerber:").replace("Portfolio Focus:", "Portfolio-Fokus:").replace("Target Industries:", "Zielbranchen:").replace("Differentiators:", "Alleinstellungsmerkmale:").replace("Silver Bullet against this competitor:", "Silver Bullet gegen diesen Wettbewerber:")} + + Für JEDEN Wettbewerber, erstelle die folgenden Sektionen einer Battlecard im JSON-Format: + 1. **competitor_name**: Der Name des Wettbewerbers. + 2. **competitor_profile**: + * **focus**: Fasse den Kernfokus des Wettbewerbers (Produkte & Branchen) in einem Satz zusammen. + * **positioning**: Beschreibe die Kernpositionierung des Wettbewerbers in 1-2 Sätzen. + 3. **strengths_vs_weaknesses**: Formuliere 3-4 prägnante Stichpunkte. Jeder Stichpunkt soll eine Stärke von "{request.company.name}" einer vermuteten Schwäche des Wettbewerbers gegenüberstellen. Beginne die Sätze z.B. mit "Während [Wettbewerber]..., bieten wir...". + 4. **landmine_questions**: Formuliere 3-5 intelligente, offene "Landminen"-Fragen, die ein Vertriebsmitarbeiter einem potenziellen Kunden stellen kann. Diese Fragen sollen die Schwächen des Wettbewerbers aufdecken oder die Stärken von "{request.company.name}" betonen, ohne den Wettbewerber direkt anzugreifen. + 5. **silver_bullet**: Übernimm die bereits formulierte "Silver Bullet" für diesen Wettbewerber. + + Regeln: + - Sei präzise, überzeugend und nutze eine aktive, vertriebsorientierte Sprache. + - Die "landmine_questions" müssen so formuliert sein, dass sie den Kunden zum Nachdenken anregen und ihn in Richtung der Vorteile von "{request.company.name}" lenken. + - Antworte ausschließlich im JSON-Format gemäß dem vorgegebenen Schema für ein Array von Battlecards. + ", + "en": f""" + Role: Sales Strategist and Coach for the B2B software company "{request.company.name}". + Task: Create a detailed "Sales Battlecard" for each of the following competitors. This battlecard should provide the sales team with concrete, actionable arguments for customer conversations. + + Information about our own company: {request.company.name} + Detailed analysis of competitors: + {competitor_data_summary} + + For EACH competitor, create the following sections of a battlecard in JSON format: + 1. **competitor_name**: The name of the competitor. + 2. **competitor_profile**: + * **focus**: Summarize the competitor's core focus (products & industries) in one sentence. + * **positioning**: Describe the competitor's core positioning in 1-2 sentences. + 3. **strengths_vs_weaknesses**: Formulate 3-4 concise bullet points. Each point should contrast a strength of "{request.company.name}" with a presumed weakness of the competitor. Start sentences with, for example, "While [Competitor]..., we offer...". + 4. **landmine_questions**: Formulate 3-5 intelligent, open-ended "landmine" questions that a sales representative can ask a potential customer. These questions should uncover the competitor's weaknesses or emphasize the strengths of "{request.company.name}" without attacking the competitor directly. + 5. **silver_bullet**: Use the "Silver Bullet" already formulated for this competitor. + + Rules: + - Be precise, persuasive, and use active, sales-oriented language. + - The "landmine_questions" must be formulated to make the customer think and guide them towards the advantages of "{request.company.name}". + - Respond exclusively in JSON format according to the specified schema for an array of battlecards. + " + } + + + response_schema = { + "type": "object", + "properties": { + "battlecards": { + "type": "array", + "items": { + "type": "object", + "properties": { + "competitor_name": {"type": "string"}, + "competitor_profile": { + "type": "object", + "properties": { + "focus": {"type": "string"}, + "positioning": {"type": "string"} + }, + "required": ['focus', 'positioning'] + }, + "strengths_vs_weaknesses": {"type": "array", "items": {"type": "string"}}, + "landmine_questions": {"type": "array", "items": {"type": "string"}}, + "silver_bullet": {"type": "string"} + }, + "required": ['competitor_name', 'competitor_profile', 'strengths_vs_weaknesses', 'landmine_questions', 'silver_bullet'] + } + } + }, + "required": ['battlecards'] + } + + try: + response = await model.generate_content_async( + prompts[request.language], + generation_config=genai.GenerationConfig( + response_mime_type="application/json", + response_schema=response_schema + ), + safety_settings={ + HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE, + }, + ) + return parse_json_response(response.text) + except Exception as e: + print(f"Error in fetch_step7_data_battlecards: {e}") + raise HTTPException(status_code=500, detail=str(e)) + +@app.post("/api/fetchStep8Data_ReferenceAnalysis") +async def fetch_step8_data_reference_analysis(request: FetchStep8DataReferenceAnalysisRequest): + competitors_summary = '\n'.join([f'- {c.name}: {c.url}' for c in request.competitors]) + + prompts = { + "de": """ + Rolle: Faktentreuer Research-Agent. Deine Antworten MÜSSEN ausschließlich auf den Ergebnissen der von dir durchgeführten Websuche basieren. + Aufgabe: Führe für jeden der folgenden Wettbewerber eine Websuche durch, um deren offizielle Referenzkunden, Case Studies oder Success Stories zu finden. + Wettbewerber: + {competitors_summary_de} + + ABLAUF FÜR JEDEN WETTBEWERBER: + 1. **SUCHE**: Führe eine gezielte Suche durch mit Phrasen wie "[Wettbewerber-Name] Referenzen", "[Wettbewerber-Name] Case Studies", "[Wettbewerber-Name] Kunden". + 2. **VALIDIERUNG**: Analysiere die Suchergebnisse. Konzentriere dich AUSSCHLIESSLICH auf Links, die zur offiziellen Domain des Wettbewerbers gehören (z.B. `wettbewerber.com/referenzen`). Ignoriere Pressemitteilungen auf Drittseiten, Partnerlisten oder Nachrichtenartikel. + 3. **EXTRAKTION**: Extrahiere die geforderten Informationen NUR von diesen validierten, offiziellen Seiten. + + SEHR WICHTIGE REGELN ZUR VERMEIDUNG VON FALSCHINFORMATIONEN: + - **NUR GEFUNDENE DATEN**: Gib NUR Kunden an, für die du eine dedizierte Case-Study-Seite oder einen klaren Testimonial-Abschnitt auf der OFFIZIELLEN Website des Wettbewerbers gefunden hast. + - **KEINE HALLUZINATION**: Erfinde KEINE Kunden, Branchen oder Zitate. Wenn du für einen Wettbewerber absolut nichts findest, gib ein leeres "references" Array zurück. Dies ist besser als falsche Informationen. + - **DIREKTER LINK**: Die 'case_study_url' MUSS der exakte, funktionierende Link zur Seite sein, auf der die Informationen gefunden wurden. + + Antworte AUSSCHLIESSLICH im JSON-Format, eingeschlossen in einem Markdown-Codeblock. + Extrahiere für JEDEN GEFUNDENEN UND VERIFIZIERTEN Referenzkunden (max. 5 pro Wettbewerber) die geforderten Felder. + ".format( + competitors_summary_de=competitors_summary + ), + "en": """ + Role: Fact-based Research Agent. Your answers MUST be based solely on the results of the web search you perform. + Task: For each of the following competitors, conduct a web search to find their official reference customers, case studies, or success stories. + Competitors: + {competitors_summary_en} + + PROCESS FOR EACH COMPETITOR: + 1. **SEARCH**: Conduct a targeted search with phrases like "[Competitor Name] references", "[Competitor Name] case studies", "[Competitor Name] customers". + 2. **VALIDATION**: Analyze the search results. Focus EXCLUSIVELY on links that belong to the competitor's official domain (e.g., `competitor.com/references`). Ignore press releases on third-party sites, partner lists, or news articles. + 3. **EXTRACTION**: Extract the required information ONLY from these validated, official pages. + + VERY IMPORTANT RULES TO AVOID MISINFORMATION: + - **ONLY FOUND DATA**: ONLY list customers for whom you have found a dedicated case study page or a clear testimonial section on the OFFICIAL website of the competitor. + - **NO HALLUCINATION**: DO NOT invent customers, industries, or quotes. If you find absolutely nothing for a competitor, return an empty "references" array. This is better than false information. + - **DIRECT LINK**: The 'case_study_url' MUST be the exact, working link to the page where the information was found. + + Respond EXCLUSIVELY in JSON format, enclosed in a markdown code block. + For EACH FOUND AND VERIFIED reference customer (max 5 per competitor), extract the required fields. + ".format( + competitors_summary_en=competitors_summary + ) + } + + response_schema = { + "type": "object", + "properties": { + "reference_analysis": { + "type": "array", + "items": { + "type": "object", + "properties": { + "competitor_name": {"type": "string"}, + "references": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": {"type": "string"}, + "industry": {"type": "string"}, + "testimonial_snippet": {"type": "string"}, + "case_study_url": {"type": "string"} + }, + "required": ["name", "industry", "testimonial_snippet", "case_study_url"] + } + } + }, + "required": ["competitor_name", "references"] + } + } + }, + "required": ['reference_analysis'] + } + + try: + response = await model.generate_content_async( + prompts[request.language], + generation_config=genai.GenerationConfig( + response_mime_type="application/json", + response_schema=response_schema + ), + tools=[genai.types.Tool(google_search_retrieval=genai.types.GoogleSearchRetrieval())], # Correct way to enable search in Python SDK + safety_settings={ + HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE, + HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE, + }, + ) + grounding_metadata = [chunk.to_dict() for chunk in response.candidates[0].grounding_metadata.grounding_chunks] if response.candidates[0].grounding_metadata else [] + parsed_data = parse_json_response(response.text) + return {**parsed_data, "groundingMetadata": grounding_metadata} + except Exception as e: + print(f"Error in fetch_step8_data_reference_analysis: {e}") + raise HTTPException(status_code=500, detail=str(e)) + +# Mount static files AFTER all API routes +if os.path.exists("dist"): + app.mount("/", StaticFiles(directory="dist", html=True), name="static") + +if __name__ == "__main__": + import uvicorn + uvicorn.run(app, host="0.0.0.0", port=8000) diff --git a/competitor-analysis-app/components/EditableCard.tsx b/competitor-analysis-app/components/EditableCard.tsx new file mode 100644 index 00000000..d2d0b37d --- /dev/null +++ b/competitor-analysis-app/components/EditableCard.tsx @@ -0,0 +1,129 @@ +import React, { useState } from 'react'; + +interface Item { + [key: string]: any; +} + +interface FieldConfig { + key: string; + label: string; + type: 'text' | 'textarea'; +} + +interface EditableCardProps { + title: string; + items: T[]; + onItemsChange: (items: T[]) => void; + fieldConfigs: FieldConfig[]; + newItemTemplate: T; + renderDisplay: (item: T, index: number) => React.ReactNode; + showAddButton?: boolean; + t: { + add: string; + cancel: string; + save: string; + } +} + +const PencilIcon = () => ( + +); +const TrashIcon = () => ( + +); + +export const EditableCard = ({ title, items, onItemsChange, fieldConfigs, newItemTemplate, renderDisplay, showAddButton, t }: EditableCardProps) => { + const [editingIndex, setEditingIndex] = useState(null); + const [editItem, setEditItem] = useState(null); + + const handleEdit = (index: number) => { + setEditingIndex(index); + setEditItem({ ...items[index] }); + }; + + const handleSave = () => { + if (editingIndex !== null && editItem) { + const newItems = [...items]; + newItems[editingIndex] = editItem; + onItemsChange(newItems); + setEditingIndex(null); + setEditItem(null); + } + }; + + const handleCancel = () => { + setEditingIndex(null); + setEditItem(null); + }; + + const handleRemove = (index: number) => { + onItemsChange(items.filter((_, i) => i !== index)); + }; + + const handleAdd = () => { + onItemsChange([...items, newItemTemplate]); + setEditingIndex(items.length); + setEditItem(newItemTemplate); + }; + + const handleInputChange = (key: string, value: string) => { + if (editItem) { + setEditItem({ ...editItem, [key]: value }); + } + }; + + const inputClasses = "w-full bg-light-secondary dark:bg-brand-secondary text-light-text dark:text-brand-text border border-light-accent dark:border-brand-accent rounded-md px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-brand-highlight"; + + return ( +
+
+

{title}

+ {(showAddButton ?? true) && ( + + )} +
+
+ {items.map((item, index) => ( +
+ {editingIndex === index && editItem ? ( +
+ {fieldConfigs.map(field => ( +
+ + {field.type === 'textarea' ? ( +