Offorte MCP Server

Offorte MCP Server

What is Offorte MCP Server about?

Offorte MCP Server acts as a bridge between AI models and the Offorte proposal platform. It lets external AI tools generate, customize, and dispatch proposals using the Model Context Protocol, turning natural‑language instructions into concrete API calls.

How to use Offorte MCP Server?

1. Install – Run the server via npx:

   {
     "mcpServers": {
       "offorte-proposals": {
         "command": "npx",
         "args": ["-y", "@offorte/mcp-server"],
         "env": {
           "OFFORTE_ACCOUNT_NAME": "<YOUR_ACCOUNT_NAME>",
           "OFFORTE_API_KEY": "<YOUR_API_KEY>"
         }
       }
     }
   }
   

2. Configure – Provide your Offorte account name and API key as environment variables.
3. Initialize – Call the get_initial_context tool first to receive usage instructions.
4. Execute tools – Use the exposed tools (e.g., create_contact, create_proposal, send_proposal) to build and send proposals.
5. Run – Use pnpm dev for development or pnpm start for production after building.

Key Features

• Context initialization with get_initial_context.
• Account management: list users via get_users.
• Contact handling: create contacts, fetch details, search organisations/people.
• Automation sets retrieval for proposal creation.
• Template access: proposal, design, email, and text templates.
• Proposal workflow: create, search, view directories, and send proposals.
• Transport options: supports stdio (default) and Server‑Sent Events (TRANSPORT_TYPE=sse).
• Node.js 20+, PNPM‑based development, and optional SSE mode.

Use Cases

• AI‑driven sales assistants that automatically generate and email proposals based on conversation context.
• Voice‑activated proposal creation, enabling hands‑free workflow for field agents.
• Automated marketing campaigns that pull template data, personalize contacts, and dispatch proposals at scale.
• Integration with LLM chat interfaces (e.g., Claude Desktop) to let users request proposal actions in natural language.

FAQ

Q: Which transport mode should I use? A: The default stdio works for most CLI‑based clients. Use TRANSPORT_TYPE=sse if your client expects Server‑Sent Events.

Q: Do I need to implement update or delete operations? A: Currently only creation and sending are supported. Update/delete functions may be added later based on feedback.

Q: How do I add this server to Claude Desktop? A: Add a single entry in claude_desktop_config.json using the npx configuration shown above, replacing placeholders with your credentials.

Q: What Node.js version is required? A: Tested with Node.js 20.x.x.

Q: How do I run the server in production? A: Execute pnpm build then pnpm start after setting the required environment variables.

Offorte MCP Server

MCP server for Offorte - Create & send proposals using AI.

This server acts as the bridge between AI agents and Offorte's proposal engine. It enables external models to create and send proposals via Offorte. Built for automation workflows, the MCP makes it easy to integrate proposal actions into AI tools, chat interfaces, and autonomous systems.

Early technology Please note that MCP (Model Context Protocol) is a new approach to AI integration. While powerful, it's still evolving and may occasionally produce unexpected or undesired results.

Table of Contents

• About Offorte
• Goals & Coverage
• Prerequisites
• Available Tools
• MCP Clients
• Development

About Offorte

Offorte is automated proposal software which helps businesses create, send, and track beautiful interactive proposals. Built for speed, flexibility, and real-world use, it combines automation and smart workflows without sacrificing the personal touch. Learn more about Offorte.

API

The MCP server is using the Offorte Public API v2. Read the API documentation for more information.

Demo

Experience the future of proposals: voice-triggered, AI-powered, fully automated. See how Offorte connects voice and workflow in this real demo.

Goals & Coverage

The goal of this project is too create & send proposals using AI via the protocol. Because of the experimental character, the full Offorte API is not covered and its limited to the tools needed to create & send proposals. Tools which could lead to an LLM updating and deleting stuff are not yet implemented. Update and delete commands might be added in the future, based on reallife results & user feedback.

Prerequisites

• Node.js (tested with Node.js 20.x.x)
• Offorte API Key (see Authentication Section of the Offorte API Docs)
• PNPM for development
• TRANSPORT_TYPE (optional): Set to sse to enable Server-Sent Events (SSE) mode, or leave unset/default for stdio (default: stdio).

Available Tools

Context & Setup

• get_initial_context – IMPORTANT: Must be called before using any other tools to initialize context and get usage instructions

Account

• get_users – Lists all account users for the current account

Automations

• get_automation_sets – Lists automation sets which are used as an optional input to create a new proposal

Contacts

• create_contact – Create a new contact (organisation or person/individual)
• get_contact_details - Get all details for a contact by id
• search_contact_organisations - Search for organisations by name in the contacts
• search_contact_people - Search for people by name in the contacts

Favorites

• get_proposal_templates – Lists proposal templates which are used as starting points to create new proposals

Proposals

• create_proposal – Create a new proposal
• get_proposal_directories – Get all proposal directories grouped by status
• search_proposals – Search for proposals by query
• send_proposal – Send a proposal to its assigned contacts

Settings

• get_design_templates – Lists available design templates which are used to create new proposals
• get_email_templates – Lists available email templates which are used to send proposals
• get_text_templates – Lists available language text templates which are used to create new proposals

MCP Clients

Currently, this MCP server has only been tested with Claude Desktop. More client examples will be added in the future.

Claude Desktop Configuration

Find your claude_desktop_config.json at Claude > Settings > Developer > Edit Config and depending on which option you'd like, add JUST ONE of the following:

NPX

Running it straight from the npm registry.

{
	"mcpServers": {
		"offorte-proposals": {
			"command": "npx",
			"args": ["-y", "@offorte/mcp-server"],
			"env": {
				"OFFORTE_ACCOUNT_NAME": "<YOUR_ACCOUNT_NAME>",
				"OFFORTE_API_KEY": "<YOUR_TOKEN>"
			}
		}
	}
}

Local Node

Dependencies should have been installed & the project is build before you use this method (pnpm install).

{
	"mcpServers": {
		"offorte-proposals": {
			"command": "node",
			"args": ["/path/to/directory/offorte-mcp-server/dist/server.js"],
			"env": {
				"OFFORTE_ACCOUNT_NAME": "<YOUR_ACCOUNT_NAME>",
				"OFFORTE_API_KEY": "<YOUR_TOKEN>"
			}
		}
	}
}

Development

To get started, clone the repository and install the dependencies. Make sure you have an .env file and it includes the proper values.

git clone https://github.com/offorte/offorte-mcp-server.git
cd offorte-mcp-server
pnpm install
pnpm dev

Commands

Check the NPM scripts for all commands, below is a short summary of the most important onces.

Script	Info
pnpm build	Build the project for production
pnpm start	Start the production server
pnpm dev	Start the development server
pnpm inspect	Inspect the server
pnpm format	Format code using Prettier and ESLint