# Deterministic Faker Data Engine MCP MCP > Deterministic Faker Data Engine lets you generate massive amounts of consistent fake user records on demand. Need 10,000 unique addresses for load testing? Done in milliseconds, and the output is repeatable every single time because you pass a seed integer. This MCP ensures your staging environments never break due to random data drift or flaky API calls. It's designed specifically for high-stakes E2E and CI/CD testing where reproducibility isn't optional. ## Overview - **Category:** productivity - **Price:** Free - **Tags:** mock-data, test-automation, prng, data-generation, privacy-compliance, synthetic-data ## Description Dealing with test data used to be a nightmare—you either risked passing actual production PII into an LLM context, which is a massive security violation, or you asked an agent to invent it. The latter wastes tokens and breaks determinism because the AI generates different names every time you run the script. This MCP fixes both problems by running all generation locally inside your infrastructure. You pass in a single seed integer, and whether you need 5 unique user names, 100 JSON addresses, or several paragraphs of body text, the output is guaranteed to be identical across runs—perfect for CI/CD pipelines like Cypress or Playwright. Since it never touches external SaaS APIs, your testing secrets stay locked down locally. Vinkius hosts this MCP so you can connect it once from any compatible client and immediately start running reliable tests. ## Tools ### generate_fake_addresses Produces a specified count of structured, random addresses. The output is deterministic if you pass an optional seed number. ### generate_fake_names Creates a defined number of fake names and identities. Like the addresses, these outputs are reproducible using a numeric seed. ### generate_fake_text Generates random lorem-ipsum text in paragraphs. You specify the count and can lock down the output with an optional seed number. ## Prompt Examples **Prompt:** ``` Generate 5 fake names using seed 42 so I can use them in my Cypress tests. ``` **Response:** ``` Using the generate_mock_names tool (count=5, seed=42): ['Amelia Anderson', 'Joseph Davis', 'Harper Moore', 'John Smith', 'Olivia Taylor']. ``` **Prompt:** ``` Give me a mock JSON array containing 3 realistic addresses. ``` **Response:** ``` Using the generate_mock_addresses tool (count=3): I have generated the addresses successfully. Example: '5842 Pine Ln, Springfield, CA 45812'. ``` ## Capabilities ### Create deterministic addresses You pass a count and an optional seed to generate structured, reproducible fake mailing addresses. ### Produce predictable identities The generator creates consistent sets of random names and personal identifiers based on your chosen seed. ### Scale text content generation It rapidly outputs large volumes of dummy paragraph text, ensuring the content is repeatable for testing purposes. ## Use Cases ### Validating a complex user signup flow A developer needs to test the full sign-up path for 50 users. Instead of writing a script that relies on random data, they ask their agent to use `generate_fake_names` and then combine those results with `generate_fake_addresses`, ensuring every single user record is perfectly consistent across all 50 entries. ### Stress testing database schema limits The ops team needs to validate that the system handles large data volumes. They use the engine to rapidly generate a JSON array of 1,000 addresses using `generate_fake_addresses` and feed it into the staging environment for load analysis. ### Building localized content features A marketing team wants to test how their app displays different types of user bio copy. They use `generate_fake_text`, setting a specific seed, so that every time they run the test, the sample paragraphs are identical for review. ### Debugging data parsing issues A QA engineer finds that date formatting fails only when names contain special characters. They use `generate_fake_names` with a specific seed to generate 20 controlled, difficult-to-parse names for reliable debugging. ## Benefits - Guaranteed reproducibility: By passing a numeric seed, you ensure the `generate_fake_names` tool spits out the exact same names every time. This eliminates flaky test failures caused by unpredictable data. - Blazing fast scale: Need 1,000 mock JSON records for load testing? The engine generates them locally in milliseconds, avoiding external API rate limits and latency spikes. - Zero security risk: Since all generation happens inside your client's infrastructure, you never transmit test intentions or fake data to a third-party SaaS endpoint. - Structured consistency: The `generate_fake_addresses` tool handles full, realistic formats. You get structured outputs that mimic real-world postal databases, perfect for schema validation. - Comprehensive content assets: Beyond names and addresses, the `generate_fake_text` tool lets you populate fields needing body copy or descriptions, keeping your mock data rich and varied. ## How It Works The bottom line is that it gives you reliable, predictable synthetic data on demand, every single time, regardless of how many times you run the test. 1. You tell your agent exactly what you need: a count (e.g., 10 records) and optionally, the numeric seed that guarantees reproducibility. 2. The MCP runs the generation process locally within your client's environment, creating the requested data structure without external calls. 3. Your agent receives the generated JSON or list of mock values, ready for immediate use in your test script or application code. ## Frequently Asked Questions **How does generate_fake_addresses work with my existing database schema?** It outputs structured data (like JSON) that you can map directly to your fields. You provide the required counts, and it gives you addresses designed to fit standard schemas. **Can I use a seed for generate_fake_names across multiple tools?** Yes. While each tool uses its own seed input, using a consistent seed value across different calls helps maintain thematic consistency in your mock data sets. **Is the output from generate_fake_text usable for real-world testing?** It generates realistic lorem-ipsum filler content. While it's not specific industry jargon, its structure is solid enough to test field length limits and display rendering. **What if I need more than 10 records from generate_fake_addresses?** Just increase the count parameter. The engine scales instantly and locally, handling thousands of records in seconds without any performance hit or API overhead. **Does running generate_fake_addresses or generate_fake_names expose my test data to external servers?** No, it runs 100% locally within your infrastructure. This means you never send any fake or sensitive data out to external APIs. The PRNG operates completely locked down on your end. **How fast is generate_fake_addresses when I need thousands of records for a test?** It's incredibly fast, generating massive volumes in milliseconds. You can request 1,000 addresses in less than five milliseconds, making it ideal for CI/CD pipelines that demand speed. **What guarantees the reproducibility when I use a seed with generate_fake_text?** The generator uses a mathematical Pseudo-Random Number Generator (PRNG) based on your input seed. This ensures that for any given seed, the exact sequence of generated paragraphs will be identical every time you run it. **Do I need special setup or dependencies to use generate_fake_names in my development workflow?** No, this MCP is designed for immediate use within your environment. You simply pass the desired count and an optional seed through your AI client; no external services or complex setups are needed. **Why do I need a 'seed' parameter?** In software testing, you often need the data to be 'fake' but 'repeatable'. If a test fails for user 'John Smith', you want it to generate 'John Smith' again when you re-run the test tomorrow. A seed guarantees mathematical consistency. **Does it use Faker.js under the hood?** No. To maintain the 'zero-dependency' utility promise and keep latency at absolute zero, it relies on a custom, lightweight Linear Congruential Generator (LCG) algorithm built directly into the MCP core. **Is my mock data sent to the cloud?** No. All generation happens locally in your environment. This ensures 100% compliance with strict enterprise development policies.