Skip to main content
Glama

Proposal Generator MCP Server

Autonomous proposal-generation server for Claude Desktop. Reads your company's templates, service profile, and rate card from Google Drive, and produces a fully branded, chart-and-table-rich .docx proposal — with zero manual formatting.

1. Install dependencies

cd proposal-mcp-server
python3 -m venv venv
source venv/bin/activate        # Windows: venv\Scripts\activate
pip install -e .

Related MCP server: MCP Dataset Onboarding Server

2. Create the Google Service Account (one-time, ~5 min)

  1. Go to console.cloud.google.com → create/select a project.

  2. Enable the Google Drive API (APIs & Services → Library → search "Drive API" → Enable).

  3. APIs & Services → Credentials → Create Credentials → Service Account.

  4. Give it a name (e.g. proposal-bot) → Create → Done (no roles needed at project level).

  5. Click the new service account → Keys tab → Add Key → JSON → downloads a file.

  6. Rename it service_account.json and place it in proposal-mcp-server/secrets/.

  7. Note the service account's email — looks like: proposal-bot@your-project.iam.gserviceaccount.com

3. Share your 3 Drive folders with the service account

In Google Drive, right-click each of Template, Resources, Output → Share → paste the service account email → give Editor access (Output needs write access; Template/Resources only need Viewer, but Editor is simplest). This is the only manual Drive step — no OAuth login needed after this.

4. Configure environment

cp .env.example .env

Fill in TEMPLATE_FOLDER_ID, RESOURCES_FOLDER_ID, OUTPUT_FOLDER_ID (the string in each folder's URL after /folders/).

Confirm/rename your Resources files to match COMPANY_PROFILE_FILENAME and RATE_CARD_FILENAME in .env (or just edit those variables to match your actual filenames).

5. Register the server with Claude Desktop

Edit your Claude Desktop config file:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "proposal-generator": {
      "command": "/absolute/path/to/proposal-mcp-server/venv/bin/python",
      "args": ["-m", "proposal_mcp.server"],
      "cwd": "/absolute/path/to/proposal-mcp-server/src",
      "env": {
        "SERVICE_ACCOUNT_FILE": "/absolute/path/to/proposal-mcp-server/secrets/service_account.json",
        "TEMPLATE_FOLDER_ID": "...",
        "RESOURCES_FOLDER_ID": "...",
        "OUTPUT_FOLDER_ID": "..."
      }
    }
  }
}

Restart Claude Desktop. You should see "proposal-generator" listed under the 🔌 connectors/tools icon.

6. Use it

Just ask, in a fresh chat:

Make a proposal for XYZ Bank who wants to switch to cloud technology. Country: India.

Claude will, on its own:

  1. Call get_mandatory_sections to see what's required.

  2. Call get_company_profile to ground the content in real capabilities.

  3. Confirm the proposed company's country from the brief or trusted company research, then call resolve_rate_card_country(country).

  4. Call get_rate_card(country, [...]) for the relevant roles only. The response includes the exact selected tab and currency; if the workbook has no country tab, it clearly reports the Constants/USD day-rate fallback.

  5. Draft each of the 9 sections (with real tables/bullets/charts and a concise technical workflow).

  6. Call generate_proposal(...) once, which renders the branded .docx and uploads it to your Output folder — returning a Drive link.

Adding new templates later

Upload a new .docx (e.g. template_rfp.docx) into the Template folder, and add an entry to template_registry.json (see assets/template_registry.example.json) in that same folder, e.g.:

{ "default": "template.docx", "rfp": "template_rfp.docx" }

Claude can then call list_templates() and pass template_id: "rfp".

Project layout

src/proposal_mcp/
  config.py              # env config + the 9 mandatory sections (hardcoded)
  drive_client.py         # Google Drive service-account wrapper
  cache.py                 # TTL cache to avoid redundant Drive downloads
  rate_card.py              # multi-sheet (per-country) rate card parser
  company_profile.py         # extracts condensed text from services doc
  charts.py                   # bar / pie / gantt chart and workflow-diagram PNG generation
  proposal_sections.py         # Pydantic schema Claude's content must follow
  docx_generator.py             # merges content into the branded template
  server.py                      # MCP tool definitions (the public API)

Token-efficiency notes

  • Every tool returns only the specific data requested (filtered rate rows, a condensed profile) — never a whole file's raw bytes/rows.

  • Chart/table/document rendering happens entirely in Python; Claude never needs to reason about layout, XML, or image encoding.

  • Rate-card selection is exact or an explicit country alias (for example, United Kingdom → UK); it never uses a risky substring match. Countries without a dedicated table automatically use the Constants sheet's USD base day rates and are labelled as such in the result.

  • Rate card / profile downloads are cached for CACHE_TTL_SECONDS, so generating several proposals in one session doesn't re-hit Drive each time.

  • generate_proposal is a single call — Claude doesn't need multiple round-trips to assemble the document piece by piece.

Available Tools

9 tools
create_project_rate_cardA

STAGE 1: Create a project-specific rate card from the master rate card.

This tool MUST be called BEFORE generate_proposal. It:

  1. Reads the master/company rate card for the specified country

  2. Analyzes the project requirements and required roles

  3. Creates a new 5-sheet workbook (Rate Card, Effort Model, Milestones, Retainer, Assumptions)

  4. Validates the workbook for internal consistency

  5. Saves it locally and uploads to the Output Drive folder

Args: client_name: Client company name (e.g., "ABC Company") project_name: Project name (e.g., "Cloud Transformation") country: Project country (e.g., "Nepal", "United Kingdom") project_scope: Brief description of project scope and requirements timeline_months: Project duration in months budget: Budget indication (e.g., "NPR 25,00,000" or "GBP 150,000") required_roles: List of dicts with keys: role, discipline, seniority, estimated_days Example: [ {"role": "Backend Engineer", "discipline": "Backend Developer", "seniority": "Senior", "estimated_days": 60}, {"role": "Frontend Engineer", "discipline": "Frontend Developer", "seniority": "Mid Senior", "estimated_days": 45}, ]

Returns JSON with the local path, Drive link, and validation status. The generated rate card becomes the authoritative source for all proposal costing.

Inputs: budget (required), country (required), client_name (required), project_name (required), +3 more. Returns: result

generate_proposalA

Generates the final branded proposal .docx and uploads it to the Output Drive folder. This is the LAST step, called once per proposal.

proposal_json must be a JSON string matching this shape: { "title": "Cloud Modernisation Proposal", "client_name": "XYZ Bank", "country": "India", "template_id": "default", "rate_card_path": "/path/to/project_rate_card.xlsx", // optional: path to project-specific rate card "sections": [ { "section_id": "executive_summary", // must match one of get_mandatory_sections() ids "blocks": [ {"type": "paragraph", "text": "..."}, {"type": "bullets", "items": ["...", "..."]}, {"type": "sub_heading", "text": "..."}, {"type": "table", "headers": ["Role","Rate"], "rows": [["Cloud Architect","..."]]}, {"type": "bar_chart", "title": "...", "categories": ["Q1","Q2"], "values": [3,5], "y_label": "FTEs"}, {"type": "pie_chart", "title": "...", "labels": ["Cloud","Security"], "values": [60,40]}, {"type": "gantt_chart", "title": "Engagement Timeline", "tasks": [{"name":"Discovery","start":"2026-08-01","duration_days":14}]}, {"type": "workflow_diagram", "title": "Illustrative Digital-Service Workflow", "workflow_steps": [ {"label":"Users", "detail":"Submit secure requests"}, {"label":"AWS WAF + ALB", "detail":"Protect and route traffic"}, {"label":"Amazon EC2", "detail":"Run application services"}, {"label":"Amazon RDS", "detail":"Store transactional data"}, {"label":"CloudWatch", "detail":"Monitor and alert"} ]} ] }, ... one entry for EACH of the 9 mandatory section ids ... ] }

Authoring standard (important): write as a senior pre-sales consultant. Make every point specific to the supplied client brief and verified tool data. Use concise, complete prose: usually one 50-90 word paragraph per idea and 3-5 parallel bullets where bullets are more scannable. Use tables for comparisons, pricing, roles, assumptions, and milestones; use charts only when the supplied numbers make a decision easier. Avoid filler, repeated claims, unsupported superlatives, and invented numbers. Preserve uncertainty as an assumption or validation item. Return only valid JSON in the required shape—no Markdown, commentary, or duplicated narrative.

The required Illustrative Technical Workflow section must be immediately before Conclusion. Include one workflow_diagram plus, where helpful, one short framing paragraph. Make the components specific to the client domain and selected platform; only use named services (for example Amazon EC2) when they are in scope or clearly labelled illustrative. Keep the diagram to its end-to-end path, rather than a detailed design.

All 9 mandatory sections (see get_mandatory_sections) must be present or this call will fail with a clear error listing what's missing. This compact structure produces a high-quality proposal without wasting output tokens. Returns the Drive link to the finished document.

Inputs: proposal_json (required). Returns: result

get_company_profileA

Returns a condensed summary of the company's services, capabilities and differentiators, to be used for writing the Executive Summary and Understanding sections.

Inputs: no named parameters. Returns: result

get_mandatory_sectionsA

Returns the fixed list and order of sections every proposal MUST contain.

Call this first. Draft all sections from the client brief and tool results, then make one generate_proposal call. Prefer decision-ready, client-specific content over generic marketing language; do not invent facts, pricing, timelines, certifications, or customer commitments.

Inputs: no named parameters. Returns: result

get_rate_cardA

Look up quote-ready manpower rates for the verified client country. Args: country: The proposed company's verified country (e.g. "India" or "United Kingdom"). Country aliases such as UK are resolved safely; this tool never uses an ambiguous substring match. roles: optional list of role names to filter to (e.g. ["Cloud Architect", "Senior Engineer"]). Omit to get all roles for that country. level: optional exact seniority filter, for example "Junior", "Mid Senior", or "Senior". Returns compact JSON with the selected country sheet/fallback metadata and the exact quote rows. If no country sheet exists, the Constants sheet is used automatically and clearly identified as USD day-rate fallback.

Inputs: country (required), level, roles. Returns: result

list_rate_card_countriesA

Returns which countries/sheets exist in the rate card, in case the exact country name needs to be confirmed before calling get_rate_card.

Inputs: no named parameters. Returns: result

list_templatesA

List available proposal templates (e.g. 'default', 'rfp', 'sow'). Call this before generate_proposal if you're unsure which template_id to use.

Inputs: no named parameters. Returns: result

resolve_rate_card_countryA

Preview the rate-card selection for a verified client country before creating a proposal. This returns the exact sheet that will be used, or a clearly marked Constants/USD fallback if the country has no dedicated tab.

Pass the client's country as supplied in the brief or confirmed by trusted company research. A company name alone is intentionally not guessed: that could quote the wrong legal entity or geography.

Inputs: country (required). Returns: result

validate_and_reload_project_rate_cardA

STAGE 1b: Validate and reload a project rate card from disk.

This tool reads the generated .xlsx file back into memory to ensure Stage 2 (proposal generation) uses the actual generated workbook as the source of truth, not the in-memory master rate card data.

Args: local_path: Path to the generated project rate card .xlsx file

Returns the parsed ProjectRateCardData as JSON.

Inputs: local_path (required). Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.4/5.0

    Scored across 9 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: retrieving mandatory sections, listing templates, fetching company profile, querying rate cards, verifying countries, creating/validating project rate cards, and generating the final proposal. Even the three rate-card-related tools are well separated: get_rate_card fetches rates, list_rate_card_countries enumerates available countries, and resolve_rate_card_country previews selection. No two tools overlap in function.

    Naming Consistency5/5

    All tool names follow a consistent snake_case verb_noun pattern with clear verbs (get, list, resolve, create, validate_and_reload, generate). Rate-card tools share the descriptive 'rate_card' suffix, and the overall naming is predictable and scannable. Deviations are none—even the longer validate_and_reload_project_rate_card is internally consistent.

    Tool Count5/5

    With 9 tools, the server is well-scoped for its purpose of generating branded proposals. Each tool earns its place in a logical pipeline—from fetching requirements to creating and validating a project-specific rate card to producing the final document. The count is within the ideal 3-15 range and neither feels sparse nor bloated.

    Completeness5/5

    The tool surface covers the full proposal-generation lifecycle: mandatory section structure, template selection, company profile retrieval, rate card lookup and creation, validation, and final generation. There are no obvious dead ends—every step required to produce a proposal is supported, and the workflow is clearly documented via tool descriptions and stage markers.

    Related MCP Connectors

    Related MCP Servers