# ThisPersonDoesNotExist MCP

> ThisPersonDoesNotExist generates unique, high-resolution JPEG images of completely synthetic human faces using StyleGAN2. Need filler avatars for a mockup or test data without worrying about privacy? This tool delivers realistic portraits instantly.

## Overview
- **Category:** design-creative
- **Price:** Free
- **Tags:** gan, stylegan2, synthetic-media, face-generation, ai-images

## Description

You need fake faces for your mockups? This engine delivers unique, high-res synthetic portraits instantly. It runs on StyleGAN2 to generate completely non-existent people.

When you call the `get_random_face` tool, it pulls a random 1024x1024 JPEG image of a person who doesn't exist. That's what it does. You get a full portrait every time you run it.

This isn't just some placeholder picture; the output is high-fidelity and built for design work. It gives you those specific, sharp assets needed to populate UIs or prototypes where real photos are either unavailable or totally inappropriate. If your job involves building mockups, testing out a new app flow, or creating dummy data sets, this tool handles it.

You never have to worry about privacy when you use this server because the faces are synthetic by nature. Since they're AI-generated and don't correspond to any real individual, you never handle, store, or even need to worry about actual personal identifying information (PII). It keeps your project clean and compliant.

Basically, it just spits out a random JPEG of a non-existent person at 1024x1024. That means you get consistently sized, professional assets without ever risking the use of real identities or copyrighted material. Need filler avatars for testing? Just run `get_random_face`. It'll give you one instantly.

Think about it: your team needs to build out a prototype that requires user photos for context—maybe an onboarding flow or a profile view. Instead of spending hours finding stock images or asking colleagues for permission, you call the tool and boom, you got a perfect, unique headshot. You're dealing with completely randomized data here. It’s not just 'a face'; it's a 1024x1024 JPEG that looks like it came straight out of professional photography gear.

It works for every scenario where real people are a liability or a hassle. Whether you're testing out a new healthcare dashboard, simulating user profiles in a financial app, or just building out some character assets for a game mockup—this server handles the visual component with pure synthetic data. You get that random generation of a full-body portrait at 1024x1024 resolution every single time.

This process ensures you can maintain absolute privacy compliance because you're never using actual identities. There is no PII involved, and nothing needs to be stored or tracked from the outside world. You just get the image data that does the job. It’s perfect for high-stakes design environments where 'real life' assets are a no-go.

It requires calling `get_random_face` in your agent. That function requests and returns a random 1024x1024 JPEG of a synthetic person, giving you that unique visual data stream immediately for testing or presentation purposes.

## Tools

### get_random_face
Requests and returns a randomly generated 1024x1024 JPEG image of a synthetic person.

## Prompt Examples

**Prompt:** 
```
Generate a random face of a person who doesn't exist.
```

**Response:** 
```
I've generated a unique 1024x1024 face using StyleGAN2. You can view the non-existent person's portrait here.
```

**Prompt:** 
```
I need a profile picture for a UI mockup. Can you get a random face?
```

**Response:** 
```
Certainly. I'm calling `get_random_face` to fetch a high-resolution synthetic portrait for your design.
```

**Prompt:** 
```
Show me a person generated by AI.
```

**Response:** 
```
Processing... Here is a completely artificial face generated by the ThisPersonDoesNotExist engine.
```

## Capabilities

### Generate synthetic faces
The tool pulls a random 1024x1024 JPEG of a non-existent person.

### Source test avatars
You get high-fidelity images to populate mockups and prototypes where real photos aren't available or appropriate.

### Maintain privacy compliance
This process ensures you never handle, store, or use actual personal identifying information (PII).

## Use Cases

### Building a new user dashboard mockup
The designer needs 10 placeholder avatars for a profile grid. They tell their agent: 'I need ten random faces.' The agent runs `get_random_face` ten times, providing diverse, high-resolution images instantly. Problem solved.

### Testing signup forms in an app
The developer is building a sign-up flow and needs placeholder profile pictures for testing the image upload component. They call `get_random_face` repeatedly, getting unique, non-PII assets to validate the front end.

### Visualizing a new character concept
The writer is creating a visual storyboard and needs a main villain's face. They use their agent to call `get_random_face` to get a unique, AI-generated portrait for the narrative visualization.

### Populating an internal documentation site
The product manager is updating a guide and needs placeholder images of 'Example User A,' 'User B,' etc. Calling `get_random_face` provides realistic, consistent-sized visuals without needing real employee photos.

## Benefits

- Stop wasting time on stock photo sites. Calling `get_random_face` immediately generates a unique, high-fidelity portrait every single time, saving you hours of searching.
- The 1024x1024 resolution is designed for modern UI/UX needs. The images are suitable for direct use in prototypes and mockups without needing extra scaling or cleanup.
- You eliminate privacy risk entirely. Because the faces come from StyleGAN2, they are guaranteed to be non-existent, making them safe for any testing environment.
- It’s an instant asset source. Instead of complex workarounds, your agent just runs `get_random_face` and you get a usable image right back in the chat.
- Works across all agents. Whether you're using Claude or Cursor, the process is simple: ask for a face, and the tool handles the rest.

## How It Works

The bottom line is that you get high-quality placeholder images instantly, without leaving your chat window or needing stock photo subscriptions.

1. Subscribe to the MCP Server and provide your access key.
2. Instruct your AI agent to run the `get_random_face` tool via natural conversation.
3. The server executes StyleGAN2, returning a unique 1024x1024 JPEG image of an artificial person.

## Frequently Asked Questions

**Are the people in these images real?**
No. Every image generated by the `get_random_face` tool is synthesized by a StyleGAN2 neural network. These individuals do not exist in the real world.

**What is the resolution of the generated faces?**
The `get_random_face` tool provides high-quality JPEG images at a fixed resolution of 1024x1024 pixels.

**Can I use these images for commercial mockups?**
Yes, these AI-generated faces are commonly used for design prototypes, testing, and creative projects where a human likeness is needed without legal or privacy constraints.

**What key do I need to use when running the `get_random_face` tool?**
You don't need a unique authentication key. This service is open-access, and you simply pass 'PUBLIC' as your access key for successful generation.

**What should I do if the `get_random_face` tool returns an error?**
If you hit a temporary issue, check the specific error message provided by your AI client. Most failures are transient, so simply retrying the call usually resolves the problem.

**Are there rate limits for using `get_random_face`?**
While the service is open-access, extremely high volumes of requests may encounter temporary throttling. If you face repeated rate limit errors, wait a few minutes and try again.

**Can I prompt for specific attributes when calling `get_random_face`?**
No, the function is designed to fetch purely random faces using StyleGAN2. You cannot input parameters like age or gender; it always generates a unique, non-existent portrait.

**How should I structure my prompt to use `get_random_face`?**
Keep your prompts straightforward and focused on the action. Simply asking your AI client to 'run get_random_face' or 'generate a random face' is enough for it to execute the tool.