This MCP server lets you generate legal documents for apps/sites (privacy policies, ToS, EULAs, cookie policies, disclaimers) and fetch full versions with a paid license.
generate_privacy_policy: creates a GDPR/CCPA/COPPA-aware privacy policy from app details, data collected, third-party SDKs, and children-under-13 flag.
generate_terms_of_service: creates a ToS based on service name, platform, key policies, and jurisdiction.
generate_eula: creates an end-user license agreement with license type and usage restrictions.
generate_cookie_policy: creates a GDPR-aware cookie policy from website info, cookie types, and third-party services.
generate_disclaimer: creates disclaimers for general, medical, financial, fitness, legal, or affiliate content.
get_full_document: retrieves the full text of a generated document using a license key or the PRIVACYPAGE_LICENSE_KEY environment variable.
Each generator returns a free 25-line preview plus a documentId; full documents are unlocked with a one-time license.
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., "@PrivacyPage MCP Server Generate a privacy policy for my fitness app FitTrack that uses Firebase and HealthKit."
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.
Give your AI agent the power to generate privacy policies, terms of service, EULAs, cookie policies, and disclaimers — while it builds your app.
Powered by PrivacyPage. Free instant previews; unlock the full document for a one-time $9.99 (no subscription, no account).
Every app shipped from Cursor, Lovable, Bolt, or v0 eventually needs legal documents — the App Store and Play Store require a privacy policy, GDPR requires cookie disclosures, and users expect terms of service. This MCP server lets the agent that's building your app generate those documents in the same conversation, filled in from what the agent already knows about your app: its name, platform, the data it collects, and the SDKs it uses.
Related MCP server: ComplianceIQ MCP Server
Requires Node.js 18+. No API key needed to generate previews.
Add to ~/.cursor/mcp.json (or .cursor/mcp.json in your project):
{
"mcpServers": {
"privacypage": {
"command": "npx",
"args": ["-y", "privacypage-mcp"]
}
}
}Add to claude_desktop_config.json (Settings → Developer → Edit Config):
{
"mcpServers": {
"privacypage": {
"command": "npx",
"args": ["-y", "privacypage-mcp"]
}
}
}{
"command": "npx",
"args": ["-y", "privacypage-mcp"],
"env": {
"PRIVACYPAGE_LICENSE_KEY": "<optional — set after purchase to auto-unlock full documents>"
}
}Tool | What it generates | Key inputs |
| GDPR/CCPA/COPPA-aware privacy policy | app name, platform, company, contact email, data collected, third-party SDKs, children under 13 |
| Terms of Service agreement | service name, company, platform, key policies (refunds, UGC, subscriptions…), jurisdiction |
| End-User License Agreement | app name, company, platform, license type, usage restrictions |
| GDPR-aware cookie policy | website name/URL, cookie types, third-party services, contact email |
| Liability disclaimer (general / medical / financial / fitness / legal / affiliate) | site name, disclaimer type, external links, contact email |
| Full text of any generated document |
|
Every generate_* tool returns a free 25-line preview, a documentId, and instructions for unlocking the full document.
You: Ship my fitness tracker app to the App Store. It uses Firebase Analytics and HealthKit.
Agent: The App Store requires a privacy policy. Let me generate one. (calls
generate_privacy_policywithappName: "FitTrack",platform: "iOS",dataCollected: ["Health Data", "Usage Analytics"],thirdPartyServices: ["Google Analytics / Firebase"],childrenUnder13: false)Agent: Here's a preview of your privacy policy — it covers HealthKit data, Firebase, GDPR and CCPA rights, and COPPA. To get the full document, purchase a one-time license at privacypage.io ($9.99, no subscription) and give me the key.
You: Here's my key:
PP-XXXX-XXXXAgent: (calls
get_full_document) Done — I've saved the full policy topublic/privacy-policy.mdand linked it in your app's settings screen.
Preview: free. Every tool returns the first 25 lines of a real, fully generated document at no cost, no account needed.
Full document: $9.99 one-time (or $24.99 for the all-documents bundle). No subscription, no recurring fees. Purchase at privacypage.io.
After purchase, set PRIVACYPAGE_LICENSE_KEY in your MCP config and the agent can unlock full documents automatically.
Rate limit: 10 document generations per hour per IP. The server reports rate-limit errors to the agent with a friendly retry message.
Variable | Purpose |
| Optional. License key used by |
| Optional. Override the API base URL (defaults to |
This server runs locally over stdio and makes HTTPS requests only to the PrivacyPage API (https://privacypage.io, or whatever PRIVACYPAGE_API_URL is set to). Everything below is verifiable in src/index.ts and src/api.ts.
What leaves your machine. Only the explicit arguments the agent passes to a tool call — the fields the generated document prints, such as app/site name, platform, company name, contact email, website URL, data-collection and cookie selections, key policies, and jurisdiction (varying by tool). For the generate_* tools these are sent as a plain JSON POST body; get_full_document sends the documentId and license key as query parameters on a GET request. No conversation context, no filesystem contents, and nothing else from the agent session is read or transmitted.
Schema-bounded. Each tool declares a fixed input schema, and every request payload is built field-by-field from those named arguments only. An agent has no channel to send extra context through these tools.
License key. PRIVACYPAGE_LICENSE_KEY (or the licenseKey argument) is sent only to the PrivacyPage API, solely to prove entitlement when fetching a full document.
What's stored server-side. The PrivacyPage service stores the generation inputs and the generated document — that's what lets a license key unlock a document by documentId after generation. This data is not used for analytics and is not shared. (Server-side behavior is a property of the privacypage.io service; this repository's source shows only what is sent.)
Rate limiting. Generation endpoints are limited to 10 document generations per hour per IP; the server reports 429 responses to the agent with a retry message.
git clone https://github.com/rushi053/privacypage-mcp.git
cd privacypage-mcp
npm install
npm run build
npm run smoke-test # handshake + tools/list over stdio
node scripts/smoke-test.mjs --call # also makes one real API callDocuments generated by PrivacyPage are professionally structured templates and AI-generated drafts. They are not legal advice; for high-stakes situations, have a lawyer review your documents.
MIT — the server. Generated documents are yours.
Generate a GDPR-aware cookie policy for a website or web app using privacypage.io. Returns a free 25-line preview and a documentId; the full document is unlocked with a one-time license ($9.99, no subscription).
| Name | Required | Description | Default |
|---|---|---|---|
| websiteUrl | No | Website URL, e.g. 'https://myapp.com' | |
| cookieTypes | Yes | Cookie categories the site uses. Common values: 'Essential cookies', 'Analytics cookies', 'Advertising cookies', 'Functional cookies', 'Performance cookies', 'Social media cookies'. | |
| websiteName | Yes | Name of the website or app, e.g. 'MyApp' | |
| contactEmail | Yes | Contact email, e.g. 'privacy@myapp.com' | |
| thirdPartyServices | Yes | Third-party services that set cookies. Common values: 'Google Analytics', 'Google Ads', 'Facebook Pixel', 'Twitter/X tracking', 'LinkedIn Insight', 'Hotjar', 'Stripe', 'None'. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral disclosure burden. It usefully discloses the external service (privacypage.io), the 25-line preview, the documentId return, and the one-time $9.99 license. However, it does not mention that user-provided data is sent to a third-party service or indicate any side effects or limitations.
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?
Two compact sentences deliver the core function first, then the return value and pricing model. No filler or repetition; every clause adds useful 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 explains the immediate output (preview and documentId) but not how the documentId relates to the sibling get_full_document tool or how the license unlock is exercised. Given there is no output schema, slightly more workflow context would make the tool easier to invoke and hand off correctly.
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 input schema already provides 100% parameter description coverage, including examples and common values for cookieTypes and thirdPartyServices. The description adds no parameter-specific meaning, so baseline 3 is appropriate.
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 uses a specific verb and resource: 'Generate a GDPR-aware cookie policy for a website or web app using privacypage.io.' It clearly distinguishes this tool from the sibling privacy policy, terms of service, EULA, and disclaimer generators by focusing on cookie policy generation.
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 the tool is for websites or web apps needing a cookie policy, which gives some context, but it does not explicitly state when to choose this instead of generate_privacy_policy or other siblings. No exclusions or alternative routing are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate a liability disclaimer (general, medical, financial, fitness, legal, or affiliate) for a website or app using privacypage.io. Returns a free 25-line preview and a documentId; the full document is unlocked with a one-time license ($9.99, no subscription).
| Name | Required | Description | Default |
|---|---|---|---|
| companyName | No | Company name, if different from the site name, e.g. 'Acme Inc.' | |
| websiteName | Yes | Name of the website or app, e.g. 'MyApp' | |
| contactEmail | Yes | Contact email, e.g. 'info@myapp.com' | |
| externalLinks | Yes | Whether the site links to external websites | |
| disclaimerType | Yes | The type of disclaimer that matches the site's content |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral burden. It goes beyond a generic 'generates' statement by revealing that the result is a 25-line preview, that a documentId is returned, and that the full document is unlocked only via a one-time $9.99 license with no subscription. This is critical behavioral context for an agent deciding whether to call the tool and how to handle the incomplete output. It does not cover rate limits or data handling, but for a document generator the paywall mechanism is the key 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 two sentences with zero filler. The first sentence front-loads the action, the document types, and the target context (website/app and privacypage.io). The second sentence precisely states the output and the pricing model. Every clause earns its place.
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 tool with 5 required parameters and no output schema, the description explains the essential output contract: a free 25-line preview, a documentId, and a paid unlock for the full document. The sibling get_full_document likely consumes the documentId, completing the workflow. It does not explain what the agent should do with the documentId or how to present the preview, but those are minor given the schema and sibling context. Missing details like authentication or rate limits are not critical for a non-destructive generation tool.
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 input schema already includes descriptions for all 5 parameters, achieving 100% coverage, so the baseline is 3. The description adds no new parameter-specific explanation; it merely lists the disclaimer types that are already captured in the enum. It does not say which fields are required or how values should be formatted, but the schema already covers that ground.
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 opens with a specific verb ('Generate') and a precise resource ('a liability disclaimer') with the six allowed types explicitly named. It also differentiates the tool from its sibling generators (privacy policy, terms, EULA, cookie policy) by identifying both the document type and the privacypage.io service. An agent can clearly tell what this tool produces and how it differs from the siblings.
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 clearly states what the tool does but does not explicitly say 'use this when...' or name the alternatives as exclusions. Still, the document-type scoping and the sibling list make the intended use case unambiguous: generate a disclaimer when that is the needed legal document. There is no explicit when-not guidance, preventing a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate an End-User License Agreement (EULA) for a software application using privacypage.io. Returns a free 25-line preview and a documentId; the full document is unlocked with a one-time license ($9.99, no subscription).
| Name | Required | Description | Default |
|---|---|---|---|
| appName | Yes | Name of the application, e.g. 'MyApp' | |
| platform | Yes | Platform the application runs on | |
| companyName | Yes | Company or developer name, e.g. 'Acme Inc.' | |
| licenseType | Yes | How the application is licensed/sold | |
| restrictions | Yes | Usage restrictions to include. Common values: 'No reverse engineering', 'No redistribution', 'No modifications', 'No commercial use (free apps)', 'No resale', 'Single user license'. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden, and it does well: it reveals the non-obvious gating behavior — returns only a 25-line preview and a documentId, with full access unlocked via a one-time $9.99 license. This prevents the false assumption that the tool returns the complete agreement.
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?
One efficient sentence presents the purpose, the provider, and the key output/pricing behavior. Every part contributes to an agent's ability to use the tool correctly, and the core action is 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 description is complete for a tool of moderate complexity: it states what it generates, what it returns, and the critical paid-unlock constraint. Since there is no output schema, mentioning the preview and documentId covers the return contract sufficiently.
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 100%, so the input schema already documents all five required parameters. The description adds no parameter-level detail, but it does not need to; the schema handles the semantics.
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 opens with a specific verb and resource: 'Generate an End-User License Agreement (EULA) for a software application using privacypage.io.' This clearly distinguishes it from sibling policy generators and states exactly what the tool produces.
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 gives a clear usage context — use this when you need a EULA for a software application on a given platform. It does not explicitly name alternatives or say when not to use it, but the legal-document type is unambiguous enough for routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate a GDPR/CCPA/COPPA-aware privacy policy for an app or website using privacypage.io. Returns a free 25-line preview and a documentId; the full document is unlocked with a one-time license ($9.99, no subscription). Fill the fields from what you know about the app being built.
| Name | Required | Description | Default |
|---|---|---|---|
| appName | Yes | Name of the app or website, e.g. 'MyApp' | |
| platform | Yes | Platform the app runs on | |
| websiteUrl | No | Website URL, if any, e.g. 'https://myapp.com' | |
| companyName | Yes | Company or developer name, e.g. 'Acme Inc.' | |
| contactEmail | Yes | Contact email for privacy inquiries, e.g. 'privacy@acme.com' | |
| dataCollected | Yes | Types of data the app collects. Common values: 'Name & Email', 'Phone Number', 'Location Data', 'Photos / Camera', 'Device Info', 'Usage Analytics', 'Payment Info', 'Health Data', 'No Personal Data'. Free-form values are also accepted. | |
| childrenUnder13 | Yes | Whether the app is directed at children under 13 (COPPA) | |
| thirdPartyServices | Yes | Third-party services/SDKs the app uses. Common values: 'Google Analytics / Firebase', 'Facebook SDK', 'AdMob / Ads', 'Stripe / Payments', 'Sentry / Crashlytics', 'Mixpanel / Amplitude', 'Push Notifications', 'None'. Free-form values are also accepted. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden and it discloses key traits: free 25-line preview, documentId, and one-time $9.99 license with no subscription. It also signals an external dependency on privacypage.io. This covers cost, output, and unlock mechanism, though it omits failure/rate-limit 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?
Two purposeful sentences with the action first, then return/pricing info, then a guidance note. No redundant phrasing or padding.
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 what the call returns (preview + documentId), the payment condition, and the source of field values. Given the rich schema and the absence of an output schema, this is nearly complete; it does not mention how documentId connects to get_full_document, but that can be inferred from the sibling tool.
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 100%, so the schema already documents all 8 properties, including enums and examples. The description adds only a generic instruction to fill fields from known app context, which is useful but does not materially deepen parameter semantics beyond the 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?
Description states a specific action ('Generate') and resource ('GDPR/CCPA/COPPA-aware privacy policy'), plus the service used (privacypage.io). This clearly differentiates from siblings like generate_terms_of_service or generate_cookie_policy, which target different legal documents.
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 implies use when the app/website needs a privacy policy and advises filling fields from known app details, but never names alternatives or says when not to use. The sibling tools are not referenced, so an agent must infer the decision from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate a Terms of Service agreement for an app or service using privacypage.io. Returns a free 25-line preview and a documentId; the full document is unlocked with a one-time license ($9.99, no subscription).
| Name | Required | Description | Default |
|---|---|---|---|
| platform | Yes | Platform the service runs on | |
| companyName | Yes | Company name, e.g. 'Acme Inc.' | |
| keyPolicies | Yes | Key policies that apply. Common values: 'Refunds allowed', 'No refunds', 'User-generated content', 'Account termination rights', 'Subscription auto-renewal', 'Free trial terms', 'Intellectual property protection'. | |
| serviceName | Yes | Name of the app or service, e.g. 'MyApp' | |
| contactEmail | Yes | Legal contact email, e.g. 'legal@acme.com' | |
| jurisdiction | Yes | Governing law jurisdiction, e.g. 'California, USA' or 'London, UK' |
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 clearly discloses that only a free 25-line preview is returned, that a documentId is generated, and that the full document requires a one-time $9.99 license with no subscription. This is meaningful behavioral context beyond a bare 'generate' statement.
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 two sentences with no redundancy. The primary purpose is front-loaded, and the second sentence efficiently conveys the return behavior and pricing model. Every sentence contributes 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?
Given the absence of an output schema, the description does well to explain the return values: a preview and a documentId. It also addresses the paid unlock model. It could be more complete by explicitly connecting the documentId to the get_full_document sibling tool, but the current information is largely sufficient for a correct call.
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 100%, so the baseline is 3 even though the description adds no parameter-specific meaning. The description does not restate or enhance the parameter definitions, but it does not need to because the schema thoroughly documents all six required fields.
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 verb ('Generate'), a precise resource ('Terms of Service agreement'), and the external service used ('privacypage.io'). It is distinct from sibling tools because it identifies the exact legal document type being generated.
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 usage context is implied by the document type: an agent should call this when a Terms of Service is needed. However, there is no explicit guidance about when to prefer this over generate_eula, generate_privacy_policy, or other sibling tools, and no exclusions are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch the full text of a previously generated document using a PrivacyPage license key. Licenses are one-time purchases at https://privacypage.io ($9.99 single document, $24.99 all-documents bundle — no subscription). If licenseKey is omitted, the PRIVACYPAGE_LICENSE_KEY environment variable is used.
| Name | Required | Description | Default |
|---|---|---|---|
| documentId | Yes | The documentId returned by a generate_* tool | |
| licenseKey | No | PrivacyPage license key. Falls back to the PRIVACYPAGE_LICENSE_KEY environment variable. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It discloses the licensing requirement, the one-time purchase model, and the environment-variable fallback, which is useful. However, it does not describe the return format or potential error conditions, leaving some uncertainty for the agent about what the call actually yields.
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?
Three sentences with the core action front-loaded. The licensing and fallback details are relevant, though the pricing specifics could be trimmed without losing essential usage guidance. Overall, it is compact and structured effectively.
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 2-parameter fetch tool, the description covers the key need-to-know items: what is fetched, the license requirement, the environment fallback, and the documentId source. The absence of an output schema makes the missing return format a minor gap, but the term 'full text' plus the simple nature of the tool keeps it reasonably complete.
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 coverage is 100%, so the baseline is 3. The description adds pricing and purchase details but does not meaningfully expand on the semantics of documentId or licenseKey beyond what the schema already states. It reinforces the fallback behavior but adds little new parameter-level meaning.
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 verb ('Fetch'), a clear resource ('the full text of a previously generated document'), and immediately distinguishes it from the sibling generate_* tools by focusing on retrieval of existing content. This is unambiguous and leaves no doubt about what the tool does.
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 makes it clear this tool is for retrieving previously generated documents, implying it should be used after a generate_* tool. It does not explicitly name alternatives or state when not to use it, but the sibling tools are all generators, so the intended context is strongly implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0generate_cookie_policygenerate_disclaimergenerate_eulagenerate_privacy_policygenerate_terms_of_serviceget_full_documentScored across 6 tools
Each generate_* tool targets a distinct legal document type (privacy policy, ToS, EULA, cookie policy, disclaimer), and get_full_document handles retrieval. No overlaps or ambiguous boundaries.
All generation tools follow a consistent generate_<document_type> pattern, and get_full_document uses the same verb_noun style. The naming is uniform and predictable.
Six tools is well-scoped for a legal document generation server: five document types plus one retrieval function. Each tool has a clear, non-redundant purpose.
The server covers the core lifecycle of document creation and full retrieval for the most common legal documents. The domain is narrow enough that the provided tools fully satisfy the stated purpose without obvious gaps.
One-step legal compliance for vibe-coded apps: privacy, terms, cookie banner and EU AI Act check.
Pre-action allow/deny for AI agents. 24 statutes, 13 jurisdictions: EU AI Act, GDPR, DPDP.
Compliant legal documents from your AI assistant: 1,100+ templates, 15 countries, free preview.
Open-source licence risk checks for AI coding agents and dependency trees.
