Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Poročila o konkurenci z avtomatizacijo

Lekcija 10 od 12 Posodobljeno 30. julij 2026 Srednje napredni
Na tej strani
  1. Avtomatiziraj obveščevalno dejavnost o konkurenci
  2. Arhitektura celovitega poročila o konkurenci
  3. Izgradnja sistema poročanja
  4. Strukturiranje poročila v uporabni JSON
  5. Primerjava obdobij za zaznavanje sprememb
  6. Načrtovanje ponavljajočega se izvajanja
  7. Najboljše prakse za uporabna poročila
  8. Ključne ugotovitve

Avtomatiziraj obveščevalno dejavnost o konkurenci

Enkratno poročilo o konkurenci zastara v nekaj dneh. Prava vrednost leži v avtomatizaciji: redno generirana poročila, enotno strukturirana, ki ti omogočajo primerjavo obdobij in sledenje strateškim premikom tvojih konkurentov.

Ta lekcija ti pokaže, kako zgraditi avtomatiziran sistem poročanja o konkurenci, ki združuje podatke iz X in spletne podatke.

Arhitektura celovitega poročila o konkurenci

Učinkovito marketinško poročilo o konkurenci zajema pet osi, njihova vrednost pa izhaja iz njihovega prekrivanja: zagon izdelka (os 3) se namreč odraža tudi v obsegu objav (os 1) in javnem mnenju (os 4). Prav to križno preverjanje loči obveščevalno dejavnost od zgolj zbiranja – signal, ki ga potrdita dve osi, si zasluži pozornost, osamljen signal pa večinoma zgolj preverjanje:

1. Dejavnost na družbenih omrežjih

Obseg objav, uporabljeni formati, angažiranost, rast občinstva.

2. Strategija vsebin

Obravnavane teme, ton, pozicioniranje, opažen uredniški koledar.

3. Zagoni in napovedi

Novi izdelki, funkcije, partnerstva, dogodki.

4. Javna percepcija

Sentiment, pritožbe, pohvale, spontane primerjave z drugimi blagovnimi znamkami.

5. Cenovna in ponudbena pozicioniranost

Spremembe cen, promocije, embalaža, posebne ponudbe.

Izgradnja sistema poročanja

Razred za poročilo o konkurenci

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

Generiranje sestavljenega poročila

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

        # Collect data for each competitor
        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
            }

        # Comparative summary
        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

Strukturiranje poročila v uporabni JSON

Za napajanje nadzorne plošče ali zbirke podatkov zahtevaj strukturirano obliko:

    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

Primerjava obdobij za zaznavanje sprememb

Vrednost avtomatiziranega sistema leži v časovni primerjavi:

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

Načrtovanje ponavljajočega se izvajanja

Integriraj svoje poročilo v opravilo cron ali Pythonov razporejevalnik:

# Weekly execution
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"]
        }
    ]
)

# Weekly report
resultat = rapport.generer_rapport(periode_jours=7)

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

Najboljše prakse za uporabna poročila

  • Doslednost: vedno uporabi isto strukturo za lažjo primerjavo.
  • Prioritetizacija: uvrsti vpoglede glede na poslovni vpliv, ne glede na obseg.
  • Izvedljivost: vsak razdelek mora voditi do priporočila.
  • Distribucija: prilagodi obliko prejemniku (vodstvo = povzetek, operativni tim = podrobnosti).
  • Arhiviranje: hrani vsa poročila za dolgoročno analizo trendov.

Ključne ugotovitve

  • Avtomatizirano poročilo o konkurenci zajema 5 osi: družbena omrežja, vsebine, zagoni, percepcija, cene.
  • Združi X Search in Web Search za celovit vpogled v vsakega konkurenta.
  • Strukturiraj rezultate v JSON za napajanje svojih nadzornih plošč.
  • Primerjava med obdobji razkriva strateške spremembe.
  • Vsak vpogled mora voditi do izvedljivega priporočila.
  • Sistematično arhiviraj svoja poročila za dolgoročno sledenje.