Protegrity AI Developer Edition Use Cases
AI Developer Edition use cases focused on agentic AI workflows and data protection.
AI Developer Use Cases
AI Developer Edition supports privacy-first development across agentic AI workflows. These use cases address sensitive data protection at every layer of the agent stack, from prompts and memory to tool interactions and multi-agent communication.
Agentic AI Use Cases
| # | Use Case | Description | Agent Layer Protected |
|---|
| 1 | Inline Privacy for Agent Runtime | Detect + mask/tokenize PII inside unstructured text directly on prompts, agent memory, and tool payloads. No need to redesign agent architecture or use schema-based controls. | Prompt orchestration |
| 2 | Safe Agent Memory | Mask or tokenize before storing memory (vector DBs, conversation history). Rehydrate only when needed. Prevents PII leakage in embeddings and compliance violations (GDPR, HIPAA). Unlocks production-grade memory systems. | Memory (long-term context) |
| 3 | Plug into Agent Frameworks | Fits naturally into LangChain, LlamaIndex, CrewAI pipelines, tool calling frameworks, RAG ingestion pipelines, and middleware (API gateway pattern). Works as both preprocessor and post-processor guardrail.
For more information about how AI Developer Edition Semantic Guardrails and Find and Protect fit into an agent orchestration framework like LangGraph, refer to Protegrity + LangGraph.
For more information about banking Portal Chatbot with Orchestrators, refer to Banking Portal Chatbot with Orchestrators. | All layers |
| 4 | Prompt PII Protection (Inbound) | Find + mask or tokenize PII in prompts before it reaches the model. Prevents raw PII from leaking into LLMs.
For more information, refer to LLM Application for Protegrity AI Developer Edition. | Prompt orchestration |
| 5 | RAG Context Protection | Tokenize sensitive fields in retrieved documents/snippets before injection into model context. Keep reversible tokens for authorized users/workflows. MCP + tool/RAG connectivity expands context access and increases attack surface. | Tool calling (APIs, RAG) |
| 6 | Tool Call Parameter Protection | Tokenize sensitive tool parameters (account numbers, SSNs, emails) before calling downstream APIs/services. Prevents accidental PII propagation into audit trails and third-party logs. MCP standardizes how tools get invoked and parameters become a leakage channel. | Tool calling (APIs, RAG) / MCP |
| 7 | Tool Response Protection | Mask/tokenize sensitive fields returned from tools before they are shown to the user, re-fed into the model loop, or written to logs. Enforces strict boundaries and monitoring at tool response boundaries. | Tool calling (APIs, RAG) / MCP |
| 8 | Safe Observability (Logs/Traces) | Tokenize prompts, retrieved context, tool args, and tool outputs before emitting traces/telemetry. Targets observability platforms like Arize and Galileo. Logs are a key control point for auditable interactions. | Logs / traces |
| 9 | Cross-Agent Artifact Protection | When multiple agents exchange artifacts (documents, summaries, structured payloads) via A2A, tokenize sensitive fields so sharing is safe-by-default. Prevents sensitive data from crossing trust boundaries in multi-agent propagation. | MCP / A2A |
Risks Addressed per Agent Layer
| Agent Layer | Risk | How AI Dev Edition Helps |
|---|
| Prompt orchestration | Raw PII leaks into LLMs | Inline PII detection + masking/tokenization before model calls |
| Memory (long-term context) | Sensitive data persists in vector stores | Tokenize before storage, rehydrate only for authorized access |
| Tool calling (APIs, RAG) | Uncontrolled data propagation to downstream systems | Parameter and response tokenization at tool boundaries |
| MCP / A2A | Unprotected multi-agent interactions | Cross-agent artifact protection, safe-by-default sharing |
| Autonomous decisions | Hard to enforce governance | Semantic guardrails, policy-driven protection |
| Logs / traces | Hidden data exfiltration risk | Tokenize all sensitive fields before emitting telemetry |
Data Protection and Security Use Cases
| Use Case | Description |
|---|
| Find and Redact | Discover sensitive data using Data Discovery API and redact or mask them. |
| Find and Protect | Discover sensitive data using Data Discovery API and protect (tokenize or encrypt) them. |
| Synthetic Data Generation | Generate synthetic training data for ML engineers and model developers. Supports responsible AI development with privacy-safe datasets. |
| Dataset Anonymization | Use the Anonymization container to discover and redact sensitive data in datasets. Ideal for preparing training data for GenAI models or sharing with third parties. Supports PII minimization and compliance. |
| Sample App Prototyping | Use prebuilt apps to simulate real-world scenarios like protecting PII in unstructured text. Accelerates evaluation and integration. |
| Python Module and Java Library Integration | Integrate protection APIs into Python and Java using lightweight modules. Useful for embedding Protegrity into existing development pipelines. |
| API Evaluation | Directly test protection and discovery APIs using tools like Postman or curl. Enables low-friction exploration of core capabilities. |
1 - Using AI Developer Edition for Agentic AI Use Cases
Sample prompts for using AI Developer Edition.
This section provides sample prompts for using AI Developer Edition for agentic AI use cases. These prompts can be used as a starting point for building your own agentic AI applications.
Training the Agent
Start by training the agent to build your application. Use the following prompt to train the agent using the AI Developer Edition documentation and readme files:
You are an AI coding agent specialized in building privacy-first applications using the Protegrity AI Developer Edition platform. Before writing any code, study the following documentation sources thoroughly:
1. **Product documentation:** https://developer.docs.protegrity.com/docs/
2. **Main repository (Docker setup, samples, config):** https://github.com/Protegrity-AI-Developer-Edition/protegrity-ai-developer-edition
3. **Python SDK source & README:** https://github.com/Protegrity-AI-Developer-Edition/protegrity-ai-developer-python
4. **Java SDK source & README:** https://github.com/Protegrity-AI-Developer-Edition/protegrity-ai-developer-java
Learn and internalize the following platform capabilities so you can write Python and Java applications when asked:
## Platform Architecture
- Containerized services orchestrated via Docker Compose (`docker compose up -d`).
- **Data Discovery** (port 8580) PII/PCI/PHI classification with confidence scoring. No registration needed.
- **Semantic Guardrail** (port 8581) Risk evaluation for GenAI conversations. Processors: `semantic`, `pii`. Verticals: Customer Service, Finance, Healthcare.
- **Synthetic Data** (port 8095, `--profile synthetic`) Privacy-preserving artificial data generation.
- **Data Protection** Tokenization, encryption, and format-preserving encryption via the API Service. **Registration required** at https://www.protegrity.com/developers/dev-edition-api.
## Python SDK (`protegrity-ai-developer-python`, PyPI v1.1.1)
Two modules:
- **`protegrity_developer_python`** Data discovery + redaction/masking/protection of unstructured text. Key functions: `configure()`, `find_and_redact()`, `find_and_protect()`, `find_and_unprotect()`.
- **`appython`** Structured data protection via `Protector` and `Session` classes. Supports single/bulk protect/unprotect, encryption/decryption, reprotect, and context managers.
## Java SDK (`protegrity-ai-developer-edition`, Maven Central v1.1.0)
Two modules:
- **`protegrity-ai-developer-edition`** Data discovery using `Discover.discover()`, `PiiProcessing.collectEntitySpans()`, `PiiProcessing.redactData()`, `PiiProcessing.protectData()`, `PiiProcessing.unprotectData()`.
- **`application-protector-java`** Structured data protection via `Protector.getProtector()`, `createSession()`, `protect()`, `unprotect()`, `reprotect()`.
## Key Conventions
- Configuration is managed via `samples/config.json` (entity map, masking char, method, threshold).
- Environment variables for protection APIs: `DEV_EDITION_EMAIL`, `DEV_EDITION_PASSWORD`, `DEV_EDITION_API_KEY`.
- Classification endpoint: `http://localhost:8580/pty/data-discovery/v2/classify`.
- Available data elements: `name`, `ssn`, `ccn`, `email`, `phone`, `address`, `city`, `postcode`, `zipcode`, `iban`, `passport`, `nin`, `text`, `string`, `number`, `datetime`, and FPE variants.
- RBAC users: `superuser` (full access, testing only), `admin`, `finance`, `marketing`, `hr`, and named users with role-specific protect/unprotect permissions.
- Entity-to-data-element mapping: PERSON→name, SOCIAL_SECURITY_ID→ssn, CREDIT_CARD→ccn, EMAIL_ADDRESS→email, PHONE_NUMBER→phone, LOCATION→address/city.
## Rules for Code Generation
- Always configure the SDK before calling any discovery or protection functions.
- For protection/unprotection operations, ensure environment variables are set and remind the user about registration.
- Use `superuser` as the default policy user for examples unless a specific role is requested.
- Handle errors appropriately: `InitializationError`, `InvalidSessionError`, `ProtectError` (Python); `ProtectorException` (Java).
- Data Discovery and Semantic Guardrail do NOT require registration, only Data Protection does.
Registering for API Access
Note: This step is only required for data protection.
To use the Data Protection capabilities of the AI Developer Edition, you need to register for API access. Use the following prompt to guide users through the registration process. Ensure that you update the variables for the information required for filling the form as required:
Run these steps. I can provide the information for the form as required:
1. Open a web browser.
2. Navigate to [https://www.protegrity.com/developers/dev-edition-api](https://www.protegrity.com/developers/dev-edition-api).
3. Specify the following details:
- First Name: <Name>
- Last Name: <Name>
- Work Email: <Email>
- Job Title: <Job Title>
- Company Name: <Company Name>
- Country: <Country>
4. Click the **Terms & Conditions** link and read the terms and conditions.
5. Select the check box to accept the terms and conditions.
6. Click **Get Started**.
Provide the Credentials for API Access
After registering for API access, you will receive an email with your credentials. Provide the credentials to the agent to enable it to use the Data Protection capabilities:
Use the following credentials to access the API. Keep this information secure:
EMail: <Email>
Password: <Password>
API Key: <API Key>
Building an Application
Now you can provide prompts to build applications using the AI Developer Edition. Here are some sample prompts for building applications:
Sample Prompt 1: Building a Customer Service Chatbot with Semantic Guardrails
This prompt guides the AI agent to build a customer service chatbot that uses Semantic Guardrail API to assess risk in real time. It classifies each conversation using the semantic processor, flags potentially sensitive or risky content, and provides immediate feedback to the user. It does all this while supporting multiple concurrent sessions.
Build a customer service chatbot that uses the Semantic Guardrail to evaluate the risk of GenAI conversations. The chatbot should be able to classify the conversation using the `semantic` processor and provide feedback to the user if the conversation is deemed risky. Use the following steps:
1. Configure the Semantic Guardrail SDK with the appropriate settings.
2. Implement a function to classify the conversation using the `semantic` processor.
3. Provide feedback to the user based on the classification results.
4. Ensure that the chatbot can handle multiple conversations simultaneously.
Sample Prompt 2: Building a Data Protection Application
This prompt asks the AI agent to build an end-to-end data protection pipeline that combines all three core capabilities, that is Data Discovery, Semantic Guardrails, and Data Protection. It scans an input file for PII, evaluates the content for risk, redacts names with a masking character, and tokenizes phone numbers so they can be recovered later. It then writes the processed output to a new file with a summary of actions taken.
Build a Python application that combines Data Discovery, Semantic Guardrails, and Data Protection to process a user-provided input file as follows:
Data Discovery: Scan the input file to identify all PII entities, including but not limited to names and telephone numbers, with confidence scores.
Semantic Guardrails: Evaluate the discovered content for risk and flag any sensitive data that should not pass through unprotected.
Redaction: Replace all detected name entities with the # character (for example, "John Smith" → "#### #####").
Tokenization: Protect all detected telephone/phone number entities using the Protegrity Data Protection API with the phone data element, so the original values can be recovered later with unprotect.
Output: Write the processed content with names redacted and phone numbers tokenized to a new output file, and print a summary showing how many names were redacted and how many phone numbers were tokenized.
Requirements:
Accept the input file path as a command-line argument.
Use the protegrity-ai-developer-python SDK (appython module).
Handle both structured (CSV/tabular) and unstructured (plain text) file formats.
Log each detected entity with its type, original value, confidence score, and the action taken (redacted or tokenized).
Sample Prompt 3: Building a Data Discovery Application
This prompt instructs the AI agent to build a Java application that uses the Data Discovery API to scan and classify text for PII entities. It walks through configuring the Java SDK, running classification on the input, displaying each detected entity with its confidence score, and handling any errors during the process.
Build a Java application that uses the Data Discovery capabilities of the AI Developer Edition to classify a given text input and identify any PII entities. The application should perform the following steps:
1. Configure the Java SDK with the appropriate settings.
2. Implement a function to classify the input text and identify PII entities.
3. Print the identified entities along with their confidence scores.
4. Handle any errors that may occur during the classification process.
Sample Prompt 4: Building a Data Protection Application with Python SDK
This prompt asks the AI agent to fetch the Protegrity AI Developer Edition Python SDK, explore the available data elements and functions, and then write a Python application. The application discovers and protects PII from a single conversational prompt referencing the GitHub repository.
I want to use Protegrity AI developer edition to protect my data. Can you get the relevant SDK. Also get me the data elements that can be used and functions. Write a python code to find and protect data . You can refer - https://github.com/Protegrity-AI-Developer-Edition/protegrity-ai-developer-edition. Install the required SDK. Also pull the core data elements and functions that I can use in Dev Edition.
Sample Prompt 5: Building a Data Protection Application with Java SDK
This prompt asks the AI agent to generate Java sample code that integrates Protegrity data protection as a preprocessor guardrail within a LangChain pipeline. It masks credit card numbers and tokenizes IP addresses and dates of birth before they reach the LLM.
Write sample code to protect the PII data as a preprocessor guardrail to Langchain pipeline. Here I want to mask credit card number, tokenize IP address, and dob.
Sample Prompt 6: Building a Data Protection Application without Docker Setup
This prompt demonstrates a minimal, no-infrastructure approach. It asks the AI agent to protect data using the Protegrity API Service directly, without spinning up any Docker containers. This approach is ideal for quick prototyping or environments where Docker is unavailable.
I want to protect data without any docker setup. Can you run the steps for me.