Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Automatizované reporty o konkurencii

Lekcia 10 z 12 Aktualizované 30. júla 2026 Mierne pokročilý
Na tejto strane
  1. Automatizuj inteligenciu o konkurencii
  2. Architektúra kompletného reportu o konkurencii
  3. Vybuduj systém reportingu
  4. Štruktúrovanie reportu do použiteľného JSON
  5. Porovnávanie období na odhalenie zmien
  6. Naplánuj opakované spúšťanie
  7. Najlepšie postupy pre použiteľné reporty
  8. Kľúčové poznatky

Automatizuj inteligenciu o konkurencii

Jednorazový report o konkurencii zastaráva v priebehu niekoľkých dní. Skutočná hodnota spočíva v automatizácii: pravidelne generované reporty s identickou štruktúrou, ktoré ti umožňujú porovnávať obdobia a sledovať strategické posuny tvojich konkurentov.

Táto lekcia ti ukáže, ako zostaviť automatizovaný systém reportingu o konkurencii, ktorý kombinuje dáta z X a webové dáta.

Architektúra kompletného reportu o konkurencii

Efektívny marketingový report o konkurencii pokrýva päť osí a ich hodnota vyplýva z ich prieniku: spustenie produktu (os 3) sa totiž prejaví aj v objeme publikácií (os 1) a vo verejnej nálade (os 4). Práve toto krížové overovanie odlišuje inteligenciu od jednoduchého zberu – signál potvrdený dvoma osami si zaslúži pozornosť, zatiaľ čo izolovaný signál si vyžaduje najmä overenie:

1. Aktivita na sociálnych sieťach

Objem publikácií, použité formáty, angažovanosť, rast publika.

2. Stratégia obsahu

Spracované témy, tón, posicioning, pozorovaný redakčný kalendár.

3. Spustenia a oznámenia

Nové produkty, funkcie, partnerstvá, podujatia.

4. Verejné vnímanie

Nálada, sťažnosti, pochvaly, spontánne porovnania s inými značkami.

5. Cenotvorba a posicioning ponuky

Zmeny cien, propagácie, balenia, špeciálne ponuky.

Vybuduj systém reportingu

Trieda pre report o konkurencii

from datetime import datetime, timedelta
import json

class RapportConcurrentiel:
    def __init__(self, client, marque_propre, concurrents):
        self.client = client
        self.marque = marque_propre
        self.concurrents = concurrents

    def collecter_donnees_x(self, handles, start, end):
        response = self.client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=f"""Collect and analyze posts
            from these accounts from {start} to {end}.

            Provide for each account:
            - Estimated number of posts
            - Content types (text, image, video, thread)
            - Most engaging posts
            - Main themes covered
            - Observed tone and positioning
            - Detected announcements or launches""",
            tools=[{
                "type": "x_search",
                "allowed_x_handles": handles,
                "from_date": start,
                "to_date": end,
                "enable_image_understanding": True
            }]
        )
        return response.output_text

    def collecter_donnees_web(self, concurrent, start, end):
        response = self.client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=f"""Search for recent news regarding
            {concurrent} between {start} and {end}.

            Focus on:
            - Press releases and news articles
            - Product or service updates
            - Leadership team changes
            - Fundraising or financial results
            - Strategic partnerships""",
            tools=[{
                "type": "web_search",
                "allowed_domains": [
                    "techcrunch.com", "lesechos.fr",
                    "usine-digitale.fr"
                ]
            }]
        )
        return response.output_text

Generovanie skompilovaného reportu

    def generer_rapport(self, periode_jours=30):
        end = datetime.now().strftime("%Y-%m-%d")
        start = (datetime.now() - timedelta(
            days=periode_jours)).strftime("%Y-%m-%d")

        sections = {}

        # Zber dát pre každého konkurenta
        for concurrent in self.concurrents:
            handles = concurrent.get("handles", [])
            nom = concurrent["nom"]

            donnees_x = self.collecter_donnees_x(
                handles, start, end
            ) if handles else "No X data"

            donnees_web = self.collecter_donnees_web(
                nom, start, end
            )

            sections[nom] = {
                "x": donnees_x,
                "web": donnees_web
            }

        # Porovnávacie zhrnutie
        rapport_final = self.client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=f"""Compile this monthly competitive report.

            Our brand: {self.marque}
            Period: {start} to {end}

            DATA PER COMPETITOR:
            {json.dumps(sections, ensure_ascii=False, indent=2)}

            Report structure:
            1. EXECUTIVE SUMMARY (5 bullet points max)
            2. COMPARATIVE TABLE (activity, sentiment, innovation)
            3. ANALYSIS PER COMPETITOR (strengths, weaknesses, moves)
            4. IDENTIFIED THREATS (ranked by urgency)
            5. OPPORTUNITIES FOR {self.marque}
            6. STRATEGIC RECOMMENDATIONS (3-5 priority actions)"""
        ).output_text

        return rapport_final

Štruktúrovanie reportu do použiteľného JSON

Ak chceš napájať dashboard alebo databázu, vyžiadaj si štruktúrovaný formát:

    def rapport_json(self, periode_jours=30):
        end = datetime.now().strftime("%Y-%m-%d")
        start = (datetime.now() - timedelta(
            days=periode_jours)).strftime("%Y-%m-%d")

        response = self.client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=f"""Generate a competitive report in JSON.

            Competitors: {json.dumps([c['nom'] for c in self.concurrents])}
            Period: {start} to {end}

            Expected format:
            {{
              "period": "{start} - {end}",
              "competitors": [
                {{
                  "name": "Competitor A",
                  "social_activity": {{
                    "post_volume": 45,
                    "average_engagement": "high",
                    "dominant_formats": ["image", "thread"]
                  }},
                  "public_sentiment": 3.8,
                  "innovations": ["description"],
                  "threats": ["description"],
                  "main_strength": "description",
                  "main_weakness": "description"
                }}
              ],
              "recommendations": ["action 1", "action 2"]
            }}""",
            tools=[
                {"type": "x_search", "from_date": start, "to_date": end},
                {"type": "web_search"}
            ]
        )
        return response.output_text

Porovnávanie období na odhalenie zmien

Hodnota automatizovaného systému spočíva v časovom porovnávaní:

def comparer_rapports(rapport_actuel, rapport_precedent):
    response = client.responses.create(
        model="grok-4.20-0309-reasoning",
        input=f"""Compare these two consecutive
        competitive reports and identify significant changes:

        PREVIOUS REPORT: {rapport_precedent}
        CURRENT REPORT: {rapport_actuel}

        Analysis:
        1. Which competitors changed strategy?
        2. What new threats appeared?
        3. What opportunities opened or closed?
        4. What trends are confirmed or reversing?
        5. Recommended immediate actions."""
    )
    return response.output_text

Naplánuj opakované spúšťanie

Integruj svoj report do úlohy cron alebo plánovača Python:

# Týždenné spúšťanie
rapport = RapportConcurrentiel(
    client=client,
    marque_propre="Your Brand",
    concurrents=[
        {
            "nom": "Competitor A",
            "handles": ["competitor_a", "competitor_a_fr"]
        },
        {
            "nom": "Competitor B",
            "handles": ["competitor_b"]
        },
        {
            "nom": "Competitor C",
            "handles": ["competitor_c"]
        }
    ]
)

# Týždenný report
resultat = rapport.generer_rapport(periode_jours=7)

# Archivácia reportu
with open(f"reports/competitor_{datetime.now().strftime('%Y-%m-%d')}.md",
          "w") as f:
    f.write(resultat)

Najlepšie postupy pre použiteľné reporty

  • Konzistentnosť: vždy používaj rovnakú štruktúru, aby sa uľahčilo porovnávanie
  • Prioritizácia: zoradzuj poznatky podľa obchodného dopadu, nie podľa objemu
  • Realizovateľnosť: každá sekcia musí viesť k odporúčaniu
  • Distribúcia: prispôsob formát príjemcovi (vedenie = zhrnutie, operatíva = detaily)
  • Archivácia: uchovávaj všetky reporty pre dlhodobú analýzu trendov

Kľúčové poznatky

  • Automatizovaný report o konkurencii pokrýva 5 osí: sociálne siete, obsah, spustenia, vnímanie, ceny
  • Kombinuj X Search a Web Search pre kompletný pohľad na každého konkurenta
  • Štruktúruj výsledky do JSON pre napájanie svojich dashboardov
  • Porovnanie medzi obdobiami odhaľuje strategické zmeny
  • Každý poznatok musí viesť k realizovateľnému odporúčaniu
  • Systematicky archivuj svoje reporty pre dlhodobé sledovanie