Model Context Protocol

The Cover Letter Engine for AI Agents

Your agent finds the jobs. StoryLenses writes the letters that get interviews. Add narrative-driven cover letter generation to any MCP-compatible agent in minutes.

Get Started

5 Composable Tools

A complete cover letter workflow for your agent — from job analysis to quality assurance.

storylenses_analyze_job

Extract 15+ structured fields from a job posting — role requirements, company challenges, culture signals, recruiter priorities.

storylenses_match_profile

Match a candidate profile against job data — identifies fit score, matching skills, career gaps, and the strongest narrative angle.

storylenses_generate_letter

Generate a story-driven cover letter using matched data and a selected narrative archetype. Supports 4 languages.

storylenses_quality_check

Score and evaluate a cover letter for relevance, narrative strength, and completeness. Returns actionable feedback.

storylenses_list_archetypes

Return available narrative archetypes with descriptions so the agent or user can select a style.

Why StoryLenses, Not a Raw LLM Call?

Your agent can send a CV and job description to GPT with a prompt. The result reads like AI slop.

StoryLenses uses narrative science — 15+ structural archetypes, deep job posting analysis, and profile-to-role matching — to produce letters that read like a human strategist wrote them. The difference is not in the writing quality. It is in the thinking that happens before the writing starts.

Raw LLM Call

✗ Generic 3-paragraph structure
✗ No job posting analysis
✗ No profile matching
✗ Same output every time
✗ Sounds like a chatbot

StoryLenses MCP

✓ 15+ narrative archetypes
✓ 15+ structured job fields extracted
✓ CV-to-role matching with gap analysis
✓ Unique output per job/candidate pair
✓ Reads like a human strategist

Quickstart

Connect in under 2 minutes.

Claude Desktop

{
  "mcpServers": {
    "storylenses": {
      "url": "https://mcp.storylenses.app/sse",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Cursor / VS Code

{
  "mcp": {
    "servers": {
      "storylenses": {
        "url": "https://mcp.storylenses.app/sse",
        "headers": {
          "Authorization": "Bearer YOUR_API_KEY"
        }
      }
    }
  }
}

TypeScript SDK

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";

const transport = new SSEClientTransport(
  new URL("https://mcp.storylenses.app/sse"),
  { requestInit: { headers: { Authorization: "Bearer YOUR_API_KEY" } } }
);
const client = new Client({ name: "my-agent", version: "1.0" });
await client.connect(transport);

Example Workflow

// 1. Analyze the job posting
const job = await client.callTool("storylenses_analyze_job", {
  job_url: "https://linkedin.com/jobs/view/12345"
});

// 2. Match candidate profile
const match = await client.callTool("storylenses_match_profile", {
  job_analysis_id: job.id,
  candidate_profile: { cv_text: resumeText }
});

// 3. Generate cover letter
const letter = await client.callTool("storylenses_generate_letter", {
  job_analysis_id: job.id,
  match_id: match.id,
  archetype: match.suggested_archetype,
  locale: "en"
});

// 4. Quality check
const score = await client.callTool("storylenses_quality_check", {
  letter_text: letter.letter_text,
  job_analysis_id: job.id
});

console.log(letter.letter_text);  // Story-driven cover letter
console.log(score.score);          // 87/100

Try It Now

Set Up Claude as a Career Agent

Create a Claude Project with these instructions. Paste a job posting and get a tailored cover letter.

Create a new Claude Project

In Claude Desktop: Projects → New Project. Name it "Career Agent" or whatever you like.

Paste these instructions as Project Instructions

You are a career agent powered by StoryLenses. You help users write story-driven cover letters using AI tools.

IMPORTANT: You have access to StoryLenses MCP tools. Some tools (like listing archetypes and analyzing job postings) work immediately. For the full workflow (matching profiles and generating letters), users need a StoryLenses API key.

IF A USER PASTES A JOB POSTING:
1. Call storylenses_analyze_job immediately — show them the extracted fields
2. Then explain: "To match this against your CV and generate a cover letter, get a free API key at storylenses.app/developers"

ONCE TOOLS ARE FULLY WORKING:
When a user shares a job posting and CV:
1. Call storylenses_analyze_job
2. Call storylenses_match_profile with job analysis and CV
3. Suggest the best narrative archetype
4. Call storylenses_generate_letter
5. Call storylenses_quality_check
6. Present the letter with score and offer to iterate

IF YOU GET AN AUTH ERROR: Guide the user to storylenses.app/developers for a free API key (10 generations/month, no credit card).

Be concise. Let the tools do the work.

Add MCP Connector

In the project, click + (Integrations) → Add custom connector:

Name:StoryLenses

URL:https://www.storylenses.app/api/mcp/endpoint

Paste a job posting and go

Open a chat in the project, paste a job posting and ask: "Analyze this job and write me a cover letter." Job analysis works instantly — for full generation, get a free API key from storylenses.app/developers.

How to Get Started

From zero to generating cover letters in 3 steps.

Create your free API key

Sign up with your email at our Developer Portal. No credit card required. You get 10 free generations per month instantly.

Configure your agent

Add the API key to your Claude Desktop, Cursor, or any MCP client config. Copy-paste the snippet from the quickstart above.

Start generating

Your agent can now analyze jobs, match profiles, and generate story-driven cover letters. Upgrade anytime from the Developer Portal when you need more.

Get Your Free API Key