powershell -ExecutionPolicy Bypass -c "pip install uv"

{
    "mcpServers": {
        "data_explore": {
            "command": "uv",
            "args": [
                "--directory",
                "C:\\Users\\<your-username>\\Documents\\mcp_servers\\mcp-server-data-exploration\\src\\mcp_server_ds",
                "run",
                "mcp-server-ds"
            ]
        }
    }
}

import os
import json
import pandas as pd
import plotly.graph_objs as go
import dash
from dash import dcc, html
from datetime import datetime
from dash.dependencies import Input, Output

from google.oauth2 import service_account
from googleapiclient.discovery import build

# Ваши константы
SITES = [
    "sc-domain:Ваш домен",
    "sc-domain:Ваш домен",
]

# Даты, за которые берем данные
START_DATE = "2024-01-01"
END_DATE   = "2025-04-12"

# ============================================================
# Обновленный список Google Updates с дополнительными данными
# ============================================================
GOOGLE_UPDATES = [
    {"name": "March 2025 core update", "start": "2025-03-13", "end": "2025-03-26"},
    {"name": "December 2024 spam update", "start": "2024-12-19", "end": "2024-12-26"},
    {"name": "December 2024 core update", "start": "2024-12-12", "end": "2024-12-18"},
    {"name": "November 2024 core update", "start": "2024-11-11", "end": "2024-12-04"},
    {"name": "Ranking is experiencing an ongoing issue (Aug 2024)", "start": "2024-08-15", "end": "2024-08-19"},
    {"name": "August 2024 core update", "start": "2024-08-15", "end": "2024-09-03"},
    {"name": "June 2024 spam update", "start": "2024-06-20", "end": "2024-06-27"},
    {"name": "March 2024 spam update", "start": "2024-03-05", "end": "2024-03-19"},
    {"name": "March 2024 core update", "start": "2024-03-05", "end": "2024-04-19"},
    {"name": "November 2023 reviews update", "start": "2023-11-08", "end": "2023-12-07"},
    {"name": "November 2023 core update", "start": "2023-11-02", "end": "2023-11-27"},
    {"name": "October 2023 core update", "start": "2023-10-05", "end": "2023-10-18"},
    {"name": "Ranking is experiencing an ongoing issue (Oct 2023)", "start": "2023-10-05", "end": "2023-10-31"},
    {"name": "October 2023 spam update", "start": "2023-10-04", "end": "2023-10-19"},
    {"name": "September 2023 helpful content update", "start": "2023-09-14", "end": "2023-09-27"},
    {"name": "August 2023 core update", "start": "2023-08-22", "end": "2023-09-07"},
    {"name": "April 2023 reviews update", "start": "2023-04-12", "end": "2023-04-25"},
    {"name": "March 2023 core update", "start": "2023-03-15", "end": "2023-03-28"},
    {"name": "February 2023 product reviews update", "start": "2023-02-21", "end": "2023-03-07"},
]

# События на сайте
EVENTS = [
    {"name": "Ваше событие",           "date": "2024-02-12"},
    {"name": "Ваше событие",         "date": "2024-02-16"},
    {"name": "Ваше событие",      "date": "2024-02-27"},
    {"name": "Ваше событие",          "date": "2024-03-20"},
    {"name": "Ваше событие",          "date": "2024-03-21"},
]

def fetch_gsc_data(property_uri, start_date, end_date, creds):
    service = build('searchconsole', 'v1', credentials=creds)
    body = {
        'startDate': start_date,
        'endDate': end_date,
        'dimensions': ['date'],
        'rowLimit': 10000
    }
    response = service.searchanalytics().query(siteUrl=property_uri, body=body).execute()
    rows = response.get('rows', [])
    data = []
    for r in rows:
        d = r['keys'][0]
        data.append({
            'date': d,
            'clicks': r.get('clicks', 0),
            'impressions': r.get('impressions', 0),
            'position': r.get('position', 0)
        })
    df = pd.DataFrame(data)
    df['date'] = pd.to_datetime(df['date'])
    return df

def load_all_data(
    start_date=START_DATE, 
    end_date=END_DATE, 
    sites=SITES, 
    creds_file="Название вашего JSON-файла"
):
    creds = service_account.Credentials.from_service_account_file(
        creds_file,
        scopes=["https://www.googleapis.com/auth/webmasters.readonly"]
    )
    all_df = []
    for s in sites:
        df_s = fetch_gsc_data(s, start_date, end_date, creds)
        df_s['domain'] = s
        all_df.append(df_s)
    big_df = pd.concat(all_df, ignore_index=True)
    return big_df

app = dash.Dash(__name__)
GLOBAL_DF = None  # кешируем загруженные данные

app.layout = html.Div([
    html.H1("GSC Дашборд - Клики, Показы, Позиция"),

    html.Div([
        html.Label("Выберите сайт(-ы):"),
        dcc.Checklist(
            id='site-selector',
            options=[{'label': site, 'value': site} for site in SITES],
            value=SITES,  
            inline=True
        ),
    ]),

    html.Div([
        html.Label("Метрики:"),
        dcc.Checklist(
            id='metric-selector',
            options=[
                {'label': 'Клики', 'value': 'clicks'},
                {'label': 'Показы', 'value': 'impressions'},
                {'label': 'Позиция', 'value': 'position'},
            ],
            # Если тут пусто, у нас нет рядов данных => ось X может стать [0..1]
            value=[],  
            inline=True
        ),
    ]),

    html.Div([
        html.Label("Показать Google Updates:"),
        dcc.Checklist(
            id='updates-toggle',
            options=[{'label': u['name'], 'value': u['name']} for u in GOOGLE_UPDATES],
            value=[],  
            inline=True
        ),
    ]),

    html.Div([
        html.Label("Показать события:"),
        dcc.Checklist(
            id='events-toggle',
            options=[{'label': e['name'], 'value': e['name']} for e in EVENTS],
            value=[],  
            inline=True
        ),
    ]),

    dcc.Graph(id='gsc-graph')
])

@app.callback(
    Output('gsc-graph', 'figure'),
    [
        Input('site-selector', 'value'),
        Input('metric-selector', 'value'),
        Input('updates-toggle', 'value'),
        Input('events-toggle', 'value'),
        Input('gsc-graph', 'relayoutData')
    ]
)
def update_graph(selected_sites, selected_metrics, selected_updates, selected_events, relayoutData):
    global GLOBAL_DF
    if GLOBAL_DF is None:
        GLOBAL_DF = load_all_data()

    print("=== CALLBACK ===")
    print("Selected events: ", selected_events)  # Проверяем в консоли, что выбрано

    fig = go.Figure()

    # Фильтруем общий DF по выбранным доменам
    filtered_df = GLOBAL_DF[GLOBAL_DF['domain'].isin(selected_sites)]

    # Если выбраны метрики, строим линии
    if selected_metrics:
        for site in selected_sites:
            df_site = filtered_df[filtered_df['domain'] == site].sort_values('date')
            for metric in selected_metrics:
                fig.add_trace(go.Scatter(
                    x=df_site['date'],
                    y=df_site[metric],
                    mode='lines',
                    name=f"{site} - {metric}"
                ))

    # Добавляем прямоугольники (vrect) для Google Updates
    for upd in GOOGLE_UPDATES:
        if upd['name'] in selected_updates:
            fig.add_vrect(
                x0=upd['start'], x1=upd['end'],
                fillcolor='red', opacity=0.1, layer='below', line_width=0,
                annotation_text=upd['name'],
                annotation_position="top left"
            )

    # Добавляем события (вертикальные линии) для выбранных ev
    for ev in EVENTS:
        if ev['name'] in selected_events:
            date_str = pd.to_datetime(ev['date']).strftime('%Y-%m-%d')
            print(f"Adding event line: {ev['name']} at {date_str}")  # Диагностика
            fig.add_vline(
                x=date_str,
                line_color='blue',
                opacity=1.0,
                line_width=2,
                layer='above'
            )
            fig.add_annotation(
                x=date_str,
                y=1,
                xref='x',
                yref='paper',
                text=ev['name'],
                showarrow=True,
                arrowhead=2,
                ax=0,
                ay=-40,
                font=dict(color='blue', size=12)
            )

    # Настройка осей
    fig.update_layout(
        title="GSC Трафик",
        xaxis_title="Дата",
        yaxis_title="Значение",
        legend_title="Сайты и метрики",
        xaxis=dict(
            tickmode='linear',
            tick0=pd.to_datetime(START_DATE),
            dtick=86400000.0,  # один день (в мс)
            tickformat="%d-%m-%Y",
            rangeslider=dict(visible=True),
        )
    )

    # Если метрик нет => вручную задаём X-ось (иначе range может оказаться [0..1])
    if not selected_metrics:
        print("No metrics selected -> Forcing x-range to START..END")
        fig.update_xaxes(range=[START_DATE, END_DATE])

    # Обработка зума (для Y-оси)
    if relayoutData:
        if "xaxis.range[0]" in relayoutData and "xaxis.range[1]" in relayoutData and selected_metrics:
            x_start = pd.to_datetime(relayoutData["xaxis.range[0]"])
            x_end = pd.to_datetime(relayoutData["xaxis.range[1]"])
            mask = (filtered_df['date'] >= x_start) & (filtered_df['date'] <= x_end)
            zoomed_df = filtered_df[mask]
            if not zoomed_df.empty:
                y_min = zoomed_df[selected_metrics].min().min()
                y_max = zoomed_df[selected_metrics].max().max()
                y_padding = (y_max - y_min) * 0.05
                fig.update_yaxes(range=[y_min - y_padding, y_max + y_padding])

    # Чтобы при переключении чекбоксов не сбрасывался зум или аннотации
    fig.update_layout(uirevision='fixed')

    return fig

if __name__ == '__main__':
    app.run(debug=True)

pip install dash plotly pandas google-auth google-auth-oauthlib google-auth-httplib2 google-api-python-client

python main.py