Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Aruannete automatiseerimine konkurentsi analüüsiks

Õppetund 10 / 12 Värskendatud 30. juuli 2026 Kesktase
Sellel lehel
  1. Konkurentsiluure automatiseerimine
  2. Täieliku konkurendiaruande arhitektuur
  3. Raportisüsteemi loomine
  4. Raporti struktureerimine kasutatavaks JSON-iks
  5. Perioodide võrdlemine muutuste tuvastamiseks
  6. Korduva käivituse planeerimine
  7. Kasutatavate aruannete parimad tavad
  8. Peamised punktid

Konkurentsiluure automatiseerimine

Ühekordne konkurendiaruanne aegub mõne päevaga. Tegelik väärtus peitub automatiseerimises: regulaarselt genereeritud aruanded, mis on ühtse struktuuriga, võimaldavad võrrelda perioode ja jälgida konkurentide strateegilisi nihkeid.

Selles õppetükis näitame, kuidas ehitada automatiseeritud konkurentsiraportite süsteem, mis ühendab X-i andmed ja veebiandmed.

Täieliku konkurendiaruande arhitektuur

Tõhus turunduslik konkurendiaruanne hõlmab viit telge, mille väärtus seisneb nende lõikumises: tootelanss (telg 3) kajastub nii avaldamismahus (telg 1) kui ka avalikus meelestatus (telg 4). Just see ristviitamine eristab luuret lihtsast andmekogumisest – kahe telje poolt kinnitatud signaal väärib tähelepanu, isoleeritud signaal aga enamasti kontrollimist:

1. Sotsiaalmeedia aktiivsus

Avaldamismaht, kasutatud formaadid, kaasatus, sihtrühma kasv.

2. Sisu strateegia

Käsitletud teemad, toon, positsioneerimine, täheldatud toimetuskalender.

3. Lansid ja teadaanded

Uued tooted, funktsioonid, partnerlused, üritused.

4. Avalik tajumine

Meelestatus, kaebused, kiitused, spontaansed võrdlused teiste brändidega.

5. Hinnastamine ja pakkumise positsioneerimine

Hinnamuutused, kampaaniad, pakendid, eripakkumised.

Raportisüsteemi loomine

Konkurendiaruande klass

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

Koondaruande genereerimine

    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 = {}

        # Kogu andmed iga konkurendi kohta
        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
            }

        # Võrdlev kokkuvõte
        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

Raporti struktureerimine kasutatavaks JSON-iks

Armatuurlaua või andmebaasi toitmiseks küsi struktureeritud formaati:

    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

Perioodide võrdlemine muutuste tuvastamiseks

Automatiseeritud süsteemi väärtus seisneb ajalis võrdluses:

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

Korduva käivituse planeerimine

Integreeri oma aruanne cron-tööna või Pythoni plaanijana:

# Nädalane käivitamine
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"]
        }
    ]
)

# Nädalaaruanne
resultat = rapport.generer_rapport(periode_jours=7)

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

Kasutatavate aruannete parimad tavad

  • Järjepidevus: kasuta alati sama struktuuri, et hõlbustada võrdlemist
  • Prioriseerimine: järjestada tõekspidamised ärimõju, mitte mahu järgi
  • Teostatavus: iga jaotis peab viima soovitusele
  • Levitamine: kohanda formaat saajale (juhtkond = kokkuvõte, operatiivtöö = detailid)
  • Arhiveerimine: hoia kõik aruanded pikaajaliseks trendianalüüsiks

Peamised punktid

  • Automatiseeritud konkurendiaruanne hõlmab 5 telge: sotsiaalmeedia, sisu, lansid, tajumine, hinnastamine
  • Kombineeri X Search ja Web Search, et saada iga konkurendi kohta terviklik ülevaade
  • Struktureeri tulemused JSON-formaati oma armatuurlaudade toitmiseks
  • Perioodide vaheline võrdlus paljastab strateegilised muutused
  • Iga tõekspidamine peab viima teostatava soovitusele
  • Arhiveeri oma aruanded süstemaatiliselt pikaajaliseks jälgimiseks