SideShift Scanner
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@SideShift Scannerrecommend creators for a brief about sustainable fashion"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Whip UGC Program Automation
The automation layer on top of SideShift for running Whip's UGC creator partnership program. Video performance data already lives in SideShift — this system organizes what SideShift (and Matthew's own judgment) surfaces, turns it into action, and keeps him from manually rebuilding a tracker every week.
Full spec: ugc-program-automation-spec.md. Design principle: Matthew never structures data by hand, and the system never contacts a creator on its own — it drafts, he sends.
flowchart LR
SS["SideShift API"] -- sync --> DB[("Local SQLite store")]
DB -- triage --> DB
DB -- compile --> DG["Weekly Digest"]
DB -- plan --> CAL["Google Calendar\n(via Calendar.app)"]
DG -- Gmail draft --> M["Matthew reviews & sends"]
AGENT["Claude Code / jcode"] -- MCP tools --> DB
M -- voice/typed notes --> AGENTThe core loop (spec section 3)
Ingest —
sync_datapulls a SideShift export into the Content Log, orrecord_manual_contentfiles raw numbers Matthew provides in chat.Triage —
run_triageflags each post Top/Normal/Underperforming relative to that creator's own recent baseline (not a fixed threshold).Surface —
compile_digest/render_digestreturn what's worth watching and why.Capture — Matthew watches, then tells the system his read in plain language;
capture_watch_notesresolves it safely, orfind_content+record_watch_notesfile it against the right content_id.Synthesize —
synthesize_feedback_draftcombines the data pattern with Matthew's notes into a starting draft. Drafted only.Calendar —
sync_calendarkeeps a dedicated Google Calendar current: payment dates, contract renewals, follow-up nudges.Digest —
run_weekly_routineruns the whole automated chain on a schedule;compile_digestanswers on-demand queries any time.
Related MCP server: Influencers Club MCP Server
Human-in-the-loop rule (spec section 5, non-negotiable)
Fully automated: parsing/filing data, flagging performance, synthesizing patterns, drafting feedback text, creating/updating calendar events, compiling the digest.
Requires Matthew's action: anything that reaches a creator. There is no
send_feedback tool anywhere in this codebase — save_feedback_draft only
ever writes a Draft row to the Feedback Log. Getting a draft in front of
Matthew is the calling agent's job (stage it as a Gmail draft with its own
gmail tool), and sending it is Matthew's.
Calendar events are the one thing this system creates/updates without
approval (low-risk, easily corrected) — but sync_calendar only ever
touches events it created itself. Every system-created event is tagged with
a stable marker; a Matthew-made event on the same calendar is never edited
or deleted, even if it collides on date or title. See
calendar_sync.py.
Setup
1. Install
git clone <this-repo>
cd sideshift-scanner
python3 -m venv .venv && source .venv/bin/activate && pip install -e ".[dev]"2. SideShift API key — copy the template and paste in your key (SideShift dashboard → Settings → Integrations):
cp .env.example .env3. Point the agent at your Python — copy the template and fill in the
absolute path to .venv/bin/python from step 1:
cp .mcp.json.example .mcp.json4. Add the dedicated calendar to Calendar.app (spec section 8 Q3).
Calendar sync works by driving macOS Calendar.app via JXA rather than the
Google Calendar REST API — no OAuth app, no consent screen, no per-machine
token refresh (see calendar_sync.py
docstring for the full rationale). Create (or pick) a dedicated Google
Calendar for the program, subscribe it in Calendar.app → Settings →
Accounts (it should already be there if it's under the same Google
account as Calendar.app), and note its exact display name. Default is
"whip"; override with calendar_name on any calendar tool/command.
5. Restart Claude Code / jcode in this folder to pick up the MCP server.
That's it — everything else is a chat message or a CLI command.
Just ask (via the agent)
Sync my latest SideShift data and run triage
What should I watch this week?
Ava just posted a TikTok that felt flat, the hook was too slow -- file that
Draft feedback for Marcus based on his last three underperforming posts
Update the calendar with upcoming payments and follow-ups
Give me this week's digestThe agent resolves freeform descriptions to the right creator/content_id
via find_content, files notes, drafts feedback, and stages Gmail drafts
using its own gmail tool — this MCP server never touches Gmail itself.
MCP tools
Tool | Spec step | Purpose |
| 1. Ingest | Pull SideShift data ( |
| 1. Ingest | File raw views + engagement when Matthew states the numbers directly |
| 2. Triage | Recompute Top/Normal/Underperforming per creator baseline |
| 2/3 | Content Log rows, filterable by creator/platform/flag/watched |
| 3/7 | Structured weekly-digest data on demand: per-creator status/trends, top performers with real metrics, trending formats, watchlist |
| 3/7 | Same, as email-ready markdown |
| 4. Capture | Resolve freeform description → candidate content_ids |
| 4. Capture | File Matthew's freeform read against a content_id |
| 4. Capture | Resolve a freeform post reference and file notes only when unambiguous |
| 5. Synthesize | Persist drafted feedback as |
| 5. Synthesize | Create a data- and note-informed feedback |
| 5 | List the Feedback Log |
| roster | Creator Roster CRUD |
| 6. Calendar | Reconcile the dedicated calendar against the roster |
| 6 | Same, without touching Calendar.app |
| 7. Digest | sync → triage → calendar sync → digest, one call |
CLI
Every tool above also has a ugc-cli command (sync, record-content, triage, digest,
creators, content, find-content, watch-notes, draft-feedback,
capture-notes, synthesize-feedback, feedback-drafts, update-creator, calendar-plan, calendar-sync,
weekly-routine):
ugc-cli weekly-routine --today 2026-08-25
ugc-cli digest --format text
ugc-cli calendar-sync --dry-runWeekly automation (spec section 6)
run_weekly_routine / ugc-cli weekly-routine runs sync → triage →
calendar sync → digest compilation in one call and returns
digest_markdown. It never touches Gmail — the scheduled agent wakeup that
drives it (see jcode's ScheduleWakeup, configured separately per
machine) stages that markdown as a Gmail draft addressed to Matthew each
Monday morning, which he reviews and sends like any other draft. On-demand
digests work the same way any time via compile_digest / ugc-cli digest.
Live dashboard
A read-only static dashboard mirrors compile_digest's output (creator
status/trends, top performers with real metrics, trending formats, watch
list, upcoming dates) at https://whip-ugc-digest.vercel.app, refreshed
daily via scripts/refresh_dashboard.sh (sync → triage → export JSON →
vercel deploy) and a separate daily ScheduleWakeup. Source lives in
web/ (single static index.html + public/data.json, no build step,
no framework) and scripts/export_digest.py (thin JSON serializer around
compile_digest, no new computation).
The URL has no authentication — anyone with the link can see creator names, handles, and performance numbers. Fine for a personal quick-glance tool; add Vercel password protection (Project Settings → Deployment Protection) before sharing the link with anyone outside your own use.
To refresh manually: ./scripts/refresh_dashboard.sh (requires the Vercel
CLI logged in via vercel login, run once per machine).
Data model (spec section 4)
Three logical tables backed by SQLite (data/ugc_analytics.db, gitignored
locally but expected to be shared via whatever sync mechanism the deploy
environment uses):
Creator Roster (
creators) — one row per creator: platforms, status, contact, contract/payment/follow-up dates, notes.Content Log (
content_items+performance_metrics+content_annotations) — one logical row per post: SideShift-sourced fields never touch Matthew/system-managed fields (watched,matthew_notes,system_synthesis,performance_flag) on resync.Feedback Log (
feedback_log) — one row per drafted feedback instance:Draftuntil Matthew sends it himself.
Triage formula (spec section 8 Q5 — first pass, not finalized)
performance_flag is a tie-aware percentile of a post's engagement rate
against that same creator's trailing 5 posts on the same platform
(never mixing e.g. YouTube Shorts' high-view/low-engagement pattern into a
TikTok baseline). Top ≥ 70th percentile, Underperforming ≤ 30th, and a
cohort under 3 prior posts is honestly reported as insufficient_data
rather than guessed. See triage.py for the
exact thresholds — these need Matthew's sign-off against real synced data
per the spec.
Tests
pytest -q96 tests cover schema/upsert semantics, triage math (including the
platform-scoping and small-cohort-honesty guarantees), CSV + mocked-API
ingestion, digest compilation and rendering, calendar plan computation +
mocked JXA reconciliation, the weekly routine orchestration, every MCP
tool via mcp.call_tool, and the CLI via Typer's CliRunner. The JXA
calendar script itself (create/update/delete, idempotency, and never
touching a non-marker event) was additionally validated by hand against a
live Google Calendar through Calendar.app — see calendar_sync.py's
module docstring.
Non-goals (v1, spec section 2)
No new video-performance analytics/dashboard (SideShift already covers this), no AI video-watching pipeline (spec section 7, Phase 2), not a CRM/payment processor (tracks dates and status, doesn't execute payments).
Available Tools
8 toolsdetect_trending_formatsB
Format/hook tags whose average performance beats the roster baseline, ranked by multiplier.
| Name | Required | Description | Default |
|---|---|---|---|
| metric | No | engagement_rate | |
| date_range_end | No | ||
| min_sample_size | No | ||
| date_range_start | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals that results are ranked by multiplier and compared against a roster baseline, but it does not explain what 'multiplier' means, how the baseline is calculated, or how date_range and sample_size parameters affect results. This is insufficient for a tool with no annotation safety signals.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that front-loads the action and unique value. Every word contributes to conveying the tool's purpose, with no filler or redundant repetition of the tool name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having an output schema (so return values need not be described), the tool has 4 optional parameters with no documentation and no annotations. The description omits critical contextual details such as what 'roster baseline' means, how the date range is applied, and what a reasonable minimum sample size is. This is inadequate for a tool with analytical logic.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 4 parameters with 0% description coverage, and the tool description does not mention any parameter or how they influence the detection. The description adds zero value in explaining metric, date range, or min_sample_size semantics, leaving the agent to guess.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: detecting format/hook tags whose average performance exceeds the roster baseline, ranked by multiplier. This is a specific verb-resource combination (detect + format/hook tags) and distinguishes it from siblings like top_performers, which likely rank creators or content.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage (finding outperforming format tags) but provides no explicit guidance on when to use this tool versus alternatives like top_performers or get_performance_summary. There are no stated exclusions or alternative recommendations, leaving the agent to infer from the tool's specific purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_content_briefA
Draft a brief tailored to a creator's style, targeting a given or trending format.
| Name | Required | Description | Default |
|---|---|---|---|
| creator_id | Yes | ||
| based_on_format | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It mentions tailoring to a creator's style and targeting a format, but does not explain what happens when based_on_format is null (e.g., whether it automatically fetches trending formats), what the output brief contains, or any side effects. The description lacks transparency about the tool's internal behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that leads with the verb 'Draft' and efficiently packs key details about the creator and format targeting. There is no unnecessary repetition or filler, making it highly concise and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with only two parameters, but the description is sparse. It does not describe the expected output (the brief's content or format), what happens if based_on_format is omitted, or any required context such as ensuring the creator exists. Given no output schema or annotations, the description should provide more completeness to be fully useful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for parameter meaning. It does: 'creator's style' maps to creator_id, and 'given or trending format' explains based_on_format (a provided format or defaulting to trending). This adds meaningful semantics beyond the schema, though it stops short of explicitly describing parameter syntax or edge cases.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action ('Draft a brief') and its specific scope ('tailored to a creator's style, targeting a given or trending format'). This distinguishes it from sibling tools like detect_trending_formats (which detects trends) and recommend_creators_for_brief (which recommends creators), making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by stating it drafts a brief for a creator, but it does not explicitly say when to use this tool over alternatives, nor does it mention prerequisites like needing a creator_id or when to leverage trending formats. Usage context is inferred rather than directly guided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_creator_profileC
Full creator profile: niche, style, platforms, performance history, best formats.
| Name | Required | Description | Default |
|---|---|---|---|
| handle | No | ||
| creator_id | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full responsibility for disclosing behavior. It mentions what the profile includes (niche, style, etc.) but does not reveal how the creator is identified, whether the operation is read-only, what happens if the creator is not found, or any other behavioral traits. It offers minimal insight beyond the output shape.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that lists the key content areas of the profile. It is front-loaded and free of filler, earning a high score for conciseness and structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having an output schema, the description is too sparse. It lacks information on identifier semantics (handle vs id), usage context among sibling tools, and any behavioral caveats. This makes it insufficient for a tool with optional parameters and ambiguous selection criteria.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not mention the parameters 'handle' or 'creator_id' at all. It does not clarify how to choose between them, whether they are required, or how they affect the returned profile. The description adds no value to understanding the input schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states what the tool returns: a full creator profile including niche, style, platforms, performance history, and best formats. The verb is implied by the tool name 'get'. It does not explicitly differentiate from sibling 'get_performance_summary', which also touches performance, but the 'full profile' wording suggests a broader scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like get_performance_summary or list_creators. There is no mention of prerequisites, typical use cases, or exclusion criteria, leaving the agent to infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_performance_summaryC
Aggregate metrics + trend direction.
scope: 'global' | 'creator' | 'campaign' | 'format'. scope_id required unless scope='global'.
| Name | Required | Description | Default |
|---|---|---|---|
| scope | No | global | |
| scope_id | No | ||
| date_range_end | No | ||
| date_range_start | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must convey behavioral traits but only states the core function and scope constraint. It does not disclose whether the operation is read-only, what data is included, how date ranges are handled, or any limits/return format. The scope_id requirement is the only behavioral detail, which is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, with two sentences that front-load the core purpose and then provide the essential parameter note. No irrelevant information or repetition of schema fields.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite being a 4-parameter tool with no annotations or output schema, the description is minimal. It omits date range semantics, return structure, when to use vs siblings, and any operational constraints. This is insufficient for an agent to confidently use the tool in all contexts.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaning for scope and scope_id by enumerating allowed values and indicating when scope_id is required. However, it does not explain date_range_start/end at all, leaving their format and purpose ambiguous. With 0% schema coverage, this partial compensation is helpful but incomplete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Aggregate metrics + trend direction,' which clearly identifies the tool's function as summarizing performance metrics with trend analysis. The scope options provide additional clarity on the resource types it covers, though it does not explicitly distinguish itself from siblings like top_performers or detect_trending_formats.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides parameter usage guidance (scope values, scope_id requirement) but does not explain when to use this tool versus alternatives. No mention of top_performers, detect_trending_formats, or other sibling tools, nor any exclusions or preferred contexts.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_creatorsA
List creators, optionally filtered by niche tag, platform, or status.
| Name | Required | Description | Default |
|---|---|---|---|
| niche | No | ||
| status | No | ||
| platform | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility. It only states the action and filters, but does not disclose pagination, output structure, authentication needs, or the default behavior when no filters are applied. This is minimal behavioral disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no unnecessary words. It efficiently communicates the core purpose without verbose filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with three optional filters and an existing output schema, the description covers the essential purpose. It does not explain all behavioral details (e.g., no-filter behavior), but given the tool's straightforward nature, this is mostly sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description merely restates the parameter names (niche, platform, status) without adding value formats, allowed values, or examples. It provides only a marginal improvement over the schema's bare parameter names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists creators, which is a specific verb+resource. It distinguishes itself from siblings like get_creator_profile (single profile) and top_performers (rankings) by focusing on the general list with optional filters.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'optionally filtered by niche tag, platform, or status' implies when to use the tool (for listing with optional criteria) but does not explicitly state when not to use it or mention alternatives. Usage is implied rather than directly compared with sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
recommend_creators_for_briefB
Rank active creators for a brief or set of format tags, with rationale for each match.
| Name | Required | Description | Default |
|---|---|---|---|
| n | No | ||
| brief_text | No | ||
| format_tags | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It only adds 'active creators' and 'rationale for each match' but fails to state whether the operation is read-only, what 'active' means, how ranking is determined, or any side effects. This is a significant gap for a tool that likely performs complex logic.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is front-loaded with the core action and includes the key input types and output feature. Every word contributes meaning without redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having an output schema, the description is too sparse for a tool with 3 optional parameters and no schema-level explanations. It lacks information on parameter interplay, what 'active' means, or how ranking works, making it incomplete for an agent to use correctly, especially given the presence of overlapping siblings like top_performers.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It mentions 'brief' and 'format tags' but does not explain the n parameter, the relationship between brief_text and format_tags, or whether they are alternatives or combined. The default behavior when values are null is also undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('Rank active creators') with a defined input ('a brief or set of format tags') and an expected output ('rationale for each match'). This distinguishes it from siblings like list_creators (no ranking) and top_performers (likely performance-based ranking without rationale).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'for a brief or set of format tags' implies the use case, but it does not explicitly state when to use this tool over alternatives such as top_performers or list_creators. There is no mention of exclusions or prerequisites (e.g., whether both brief_text and format_tags can be used together).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sync_dataA
Pull latest data via the active ingestion adapter and upsert into the local store.
method='csv': source is a directory containing creators.csv / campaigns.csv /
content_items.csv / performance_metrics.csv (see sample_data/).
method='api': pulls from the real SideShift API. Requires the SIDESHIFT_API_KEY
env var (Settings -> Integrations in the SideShift dashboard).
since (YYYY-MM-DD) limits ingestion to records on/after that date.
| Name | Required | Description | Default |
|---|---|---|---|
| since | No | ||
| method | No | csv | |
| source | No | sample_data |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral disclosure burden. It discloses side effects (upsert into local store), a required API key, input constraints (`since` format), and CSV source layout. It leaves ambiguity around `source` in API mode and omits return/error behavior, but it covers the most operationally important behaviors.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the primary purpose and then adds method-specific details in compact lines. Every sentence adds value, with no filler or repetition. The only minor inefficiency is the slightly vague 'active ingestion adapter' phrase, which could be replaced with a more concrete term.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 3 optional parameters, no output schema, no annotations, and is flanked by query tools, this description covers the essential invocation details: method choice, source layout, API key requirement, and date filtering. It lacks return/error behavior and clarification of `source` in API mode, but the core usage context is present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It explains the meaning of `method` by enumerating 'csv' and 'api' behaviors, details the `source` directory contents for CSV, and specifies the `since` date format. It does not clarify what `source` means for the API method, but otherwise provides substantial parameter context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Pull latest data via the active ingestion adapter and upsert into the local store'), identifying both the operation (pull/upsert) and the resource (local store). This clearly differentiates sync_data from the sibling query and analysis tools, which focus on reading/presenting data rather than ingesting it.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides explicit method selection guidance: method='csv' defines the source directory and expected filenames, while method='api' pulls from the real SideShift API and requires SIDESHIFT_API_KEY. It also explains the `since` date filter. It does not explicitly state when not to use the tool or compare against alternatives, but the method-specific instructions give clear context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
top_performersA
Ranked content items by a chosen metric (views/likes/comments/shares/saves/conversions/revenue/engagement_rate).
include_unlisted: whether to include content from creators no longer returned by SideShift's /creators (ghost handles or removed accounts -- SideShift excludes those by design, so this tool can't fetch more about who they are, just show or hide their content).
| Name | Required | Description | Default |
|---|---|---|---|
| n | No | ||
| metric | No | views | |
| date_range_end | No | ||
| date_range_start | No | ||
| include_unlisted | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since annotations are absent, the description carries the burden of disclosing behavioral traits. It reveals a non-obvious limitation: content from creators excluded by SideShift's /creators can only be shown/hidden, not enriched. This adds meaningful context beyond a simple read operation, though it omits other aspects like auth or rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description front-loads the purpose in a single sentence, then provides a necessary but slightly verbose explanation of the 'include_unlisted' parameter. The structure is logical and efficient, though the second part could be tightened without losing essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the core behavior and the most intricate parameter, and an output schema exists to handle return values. However, it does not explicitly state sorting order or date range semantics, and lacks usage context relative to siblings. Given the tool's complexity, this is reasonably complete but not exhaustive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description is the only source for parameter meaning. It explicitly lists the options for the 'metric' parameter and explains the 'include_unlisted' parameter in detail, including its data-source implications. Other parameters like 'n' and date ranges are self-explanatory from their names and defaults, so the description adds substantial value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Ranked content items by a chosen metric' and enumerates all supported metrics (views/likes/comments/shares/saves/conversions/revenue/engagement_rate). This specifies the verb (rank), resource (content items), and scope, effectively distinguishing it from sibling tools like get_performance_summary or detect_trending_formats.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives such as get_performance_summary or detect_trending_formats. The description focuses solely on functionality and parameter details, without specifying use cases, exclusions, or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
8 tool updates
v0.1.0- First observed
detect_trending_formats - First observed
generate_content_brief - First observed
get_creator_profile - First observed
get_performance_summary - First observed
list_creators - First observed
recommend_creators_for_brief - First observed
sync_data - First observed
top_performers
TDQS
Scored across 8 tools
Each tool targets a distinct function: data ingestion, listing vs. detailed profiles, aggregate summaries vs. ranked items, trend detection, creator recommendation, and brief generation. No two tools have overlapping purposes; even related tools (recommend vs. generate) are clearly separated.
Most tools follow a clear verb_noun pattern (sync_data, list_creators, get_creator_profile, detect_trending_formats, generate_content_brief). The exception is 'top_performers' which is noun-only, and 'recommend_creators_for_brief' is slightly longer but still verb_noun. Overall consistent and readable, with one minor deviation.
8 tools is within the optimal 3-15 range, covering ingestion, querying, analytics, and recommendation without feeling bloated. Each tool serves a distinct need in the creator analytics domain.
The tool set covers the core workflow: data ingestion, creator browsing/detail, performance analysis, trend detection, and brief generation. Minor gaps exist (e.g., no direct tool for listing campaigns or content items beyond top_performers), but these are edge cases and the main workflow is well-supported.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Remote MCP server for China brand visibility, destination demand, and KOL discovery workflows.
MCP server for VC pitch-deck scoring, thesis-fit matching, and deal-flow management.
- MysocialOAuthio.mysocial
Social media MCP server: your Instagram, TikTok, YouTube, LinkedIn and Threads history for your AI.
Cloud MCP for project data, analytics, research, content planning, media generation, and growth.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceMCP server for analyzing TikTok data for insight extraction5MIT
- AlicenseAqualityBmaintenanceMCP server for the Influencers Club API — creator enrichment, discovery, audience analysis, content data, batch operations, and account management.224MIT
- FlicenseNot gradedqualityBmaintenanceRemote MCP server that provides Creator Recommendation API tools (creator_research, creator_tagged_media, etc.) with secure authentication, rate limiting, and OAuth support for Claude clients.-
- FlicenseBqualityCmaintenanceA platform-agnostic MCP server that connects Claude to campaign data, institutional knowledge, and historical performance for paid media teams, enabling automated analysis, reporting, and debugging.73-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/matthewhuang11/sideshift-scanner'
If you have feedback or need assistance with the MCP directory API, please join our Discord server