proposal-generator-mcp
Reads proposal templates, company profile, and rate card data from specified Google Drive folders, and uploads the generated branded .docx proposal back to an output folder.
Click on "Deploy 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., "@proposal-generator-mcp Make a proposal for XYZ Bank who wants to switch to cloud technology. Country: India."
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.
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)
Go to console.cloud.google.com → create/select a project.
Enable the Google Drive API (APIs & Services → Library → search "Drive API" → Enable).
APIs & Services → Credentials → Create Credentials → Service Account.
Give it a name (e.g.
proposal-bot) → Create → Done (no roles needed at project level).Click the new service account → Keys tab → Add Key → JSON → downloads a file.
Rename it
service_account.jsonand place it inproposal-mcp-server/secrets/.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 .envFill 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.jsonWindows:
%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:
Call
get_mandatory_sectionsto see what's required.Call
get_company_profileto ground the content in real capabilities.Confirm the proposed company's country from the brief or trusted company research, then call
resolve_rate_card_country(country).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.Draft each of the 9 sections (with real tables/bullets/charts and a concise technical workflow).
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_proposalis a single call — Claude doesn't need multiple round-trips to assemble the document piece by piece.
Available Tools
9 toolscreate_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:
Reads the master/company rate card for the specified country
Analyzes the project requirements and required roles
Creates a new 5-sheet workbook (Rate Card, Effort Model, Milestones, Retainer, Assumptions)
Validates the workbook for internal consistency
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
Scored across 9 tools
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.
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.
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.
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
Generate on-brand proposals, reports, and contracts instantly. Auto-extracts brand from any URL.
Finished, on-brand .pptx and .docx from a brief - quality-gated by an agentic consulting team.
Turn sales-call transcripts into traced proposals, contracts, and NDAs.
Convert, create and edit Word, PowerPoint, Excel and PDF documents from any AI agent.
Related MCP Servers
- -licenseBqualityNot gradedmaintenanceAutomates the creation of standardized documentation by extracting information from source files and applying templates, with integration capabilities for GitHub, Google Drive, and Perplexity AI.33-
- AlicenseNot gradedqualityDmaintenanceEnables automated dataset processing and onboarding using Google Drive integration. Provides metadata extraction, data quality assessment, and contract generation for CSV/Excel files through natural language interactions.1MIT
- FlicenseBqualityNot gradedmaintenanceGenerates professional, AI-powered freelance project proposals including executive summaries, scopes of work, and pricing structures. It leverages Claude to create tailored proposals based on specific project descriptions, budgets, and timelines.1-
- AlicenseBqualityDmaintenanceEnables creating professional Word documents from markdown or structured content with fast, customized formatting via natural language.71ISC