# Family Photo Sharing Logic Engine AI Agent Connect

> Family Photo Sharing Logic Engine MCP handles the complex math of photo privacy. It lets your AI client evaluate consent flags, group memberships, and time-based rules to decide exactly who can see specific albums. Instead of manually checking permissions, you let your agent handle the logic of who is allowed in and when access expires.

## Overview
- **Category:** security
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_vVrVCzU0l2K4Z9G7A3gcEX3fPkGvvCCF1DXZTlYF/ai-agent-connect
- **Tags:** photo-sharing, permissions, privacy-logic, audience-management, temporal-rules

## Description

You shouldn't have to manually cross-reference permission lists every time you share a photo album. This MCP acts as a dedicated logic engine that your AI client uses to enforce privacy rules. It looks at consent settings, audience groups, and even how much time has passed since an album was created to determine access. If you need to know if a specific relative is in the right group, the agent can check that instantly. If you want to see when a shared link will stop working, the engine provides a clear schedule. It handles the heavy lifting of temporal constraints, ensuring that albums aren't shared outside of their intended windows. You get a reliable way to manage digital boundaries without the manual guesswork.

## Tools

### validate_audience_access
This tool checks if a specific user belongs to an audience group that has permission to view an album.

### analyze_sharing_permissions
This tool evaluates all privacy rules and preference flags to identify exactly which recipients can view an album.

### check_temporal_constraints
This tool verifies if an album is still within its valid date range for sharing based on the current date.

### get_share_expiration_calendar
This tool generates a schedule showing when access to specific albums will expire for various recipients.

## Prompt Examples

**Prompt:** 
```
Who is allowed to see album 'vacation_2023' among users 'user_1', 'user_2', and 'user_3'?
```

**Response:** 
```
The allowed recipients for album 'vacation_2023' are 'user_1' and 'user_3'. 'user_2' is blocked due to privacy settings.
```

**Prompt:** 
```
Is the album created on '2023-01-01' still valid for sharing today, '2024-05-20'?
```

**Response:** 
```
Yes, the album is within its valid sharing window.
```

**Prompt:** 
```
When will access to album 'family_reunion' expire for recipient 'user_99'?
```

**Response:** 
```
Access for 'user_99' to the 'family_reunion' album is set to expire on 2024-12-31.
```

## Capabilities

### Permission Auditing
Your agent uses this to identify which users are currently blocked or allowed for a specific album.

### Group Membership Verification
The AI checks if a user is part of a permitted audience group before suggesting a share.

### Expiration Tracking
Your agent calculates when access rights will lapse using the expiration calendar.

### Time-based Validation
The engine checks if an album's creation date allows for sharing under current temporal rules.

## Use Cases

### Automated Privacy Audits
Your agent scans an album to see if any unauthorized users have access based on current group settings.

### Managing Temporary Access
You use the expiration calendar to plan when to revoke access for seasonal event photos.

### Enforcing Consent Rules
The engine blocks sharing requests if a user's consent flag is set to private.

### Validating Sharing Windows
The AI checks if an old album is still eligible for sharing based on its original creation date.

## Benefits

- Removes manual permission checks by automating consent evaluation.
- Prevents accidental over-sharing through strict temporal constraint checks.
- Provides a clear schedule of access expirations to prevent stale permissions.
- Centralizes privacy logic so your AI client can make consistent decisions.

## How It Works

The MCP connects your AI client to your photo permission database to run logic checks.

1. Connect your preferred MCP-compatible client to Vinkius.
2. The agent receives a request to check or share an album.
3. The MCP runs the specific logic tool like permission analysis or temporal checks.
4. The agent receives the result and tells you who can or cannot see the photos.

## Frequently Asked Questions

**How does this MCP handle photo privacy?**
It uses a logic engine to evaluate consent flags and audience group memberships to determine access.

**Can I see when a photo share will expire?**
Yes, you can use the expiration calendar tool to get a schedule of when access will cease.

**What clients can use this MCP?**
You can use this with any MCP-compatible client like Claude, Cursor, Windsurf, or VS Code.

**Does it check if an album is too old to share?**
Yes, the temporal constraints tool verifies if an album is within its valid sharing window.

**How are audience permissions verified?**
The validate_audience_access tool checks if a user is a member of a permitted group.

**How does the system handle blocked users?**
The `analyze_sharing_permissions` tool identifies blocked recipients by checking the user's explicit block list and individual consent flags.

**Can I see when a user's access will expire?**
Yes, you can use `get_share_expiration_calendar` to retrieve a schedule of all upcoming expiration dates for an album.

**How are audience groups verified?**
The `validate_audience_access` tool verifies if a specific user is a member of a permitted audience group.