# Enemy Avoidance Seater MCP for AI Agents MCP

> Enemy Avoidance Seater is an automated seating engine for event planners. It assigns guests to tables while strictly enforcing social constraints and enemy proximity rules. It identifies specific bottlenecks when a perfect arrangement is impossible, saving you from manual spreadsheet shuffling.

## Overview
- **Category:** logistics
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_DlWOw2YYxvp3idhkVVCEtKIIx1GQdmkWQv4wqImP/mcp
- **Tags:** seating, optimization, event-management, constraints, automation

## Description

Managing a guest list for a large wedding or corporate gala is a logistical nightmare. You have to balance table sizes while making sure certain people don't end up sitting next to each other. The Enemy Avoidance Seater handles this math for you. Instead of manually moving names around in a spreadsheet, you just give your agent the list of people, the available tables, and the rules for who needs to stay away from whom. It finds a layout that works. If the rules are too strict and a solution doesn't exist, it tells you exactly who is causing the problem so you can adjust the constraints. It's part of the Vinkius catalog, making it easy to plug into your existing workflow. You get a finished seating plan without the manual trial and error of moving names one by one.

## Tools

### execute_seating_algorithm
Calculates a seating arrangement that keeps specific guests apart while filling tables. It finds the best layout based on your rules.

### verify_integrity
Checks a current seating plan to see if it follows all capacity and proximity rules. It acts as a final audit for your plans.

## Prompt Examples

**Prompt:** 
```
Can you seat Alice, Bob, and Charlie at Table 1 (capacity 2) and Table 2 (capacity 2), knowing that Alice and Bob are enemies with a distance of 1?
```

**Response:** 
```
### Seating Arrangement

| Table | Guests |
| :--- | :--- |
| **Table 1** | Alice, Charlie |
| **Table 2** | Bob |

**Notes:**
* Alice and Bob are successfully separated by one table.
* All table capacities are respected.
```

**Prompt:** 
```
Check if this plan is valid: Guest X at Table 1, Guest Y at Table 2, where X and Y are enemies with minDistanceTables of 1.
```

**Response:** 
```
✅ **Plan Valid**

The arrangement is valid because the guests are in non-adjacent tables, satisfying the minimum distance requirement of 1.
```

**Prompt:** 
```
Try to seat 5 people at a single table with capacity 2.
```

**Response:** 
```
❌ **IMPOSSIBLE**

The following guests could not be seated due to capacity constraints:
* Guest 3
* Guest 4
* Guest 5

**Reason:** Table capacity is only 2, but 5 guests were requested.
```

## Capabilities

### Assign guests to tables
Automatically places guests at tables based on your specific capacity limits.

### Enforce social distancing
Keeps specific individuals apart by enforcing minimum table distance rules.

### Identify seating bottlenecks
Pinpoints exactly which guests are making a valid seating plan impossible.

### Audit seating plans
Checks an existing layout to ensure no rules or capacities are being broken.

### Generate valid layouts
Creates a complete seating arrangement that satisfies all your social constraints.

## Use Cases

### Managing Wedding Drama
A bride wants to ensure two feuding aunts are at opposite ends of the room. You ask your agent to seat them with a minimum distance of 3 tables.

### Corporate Gala Seating
A company needs to seat 300 VIPs without putting business rivals at the same table. The agent uses the rules to build a safe layout.

### School Reunion Planning
Organizers need to manage seating for 500 alumni with specific no-sit rules. The agent handles the massive guest list and capacity limits.

### Charity Dinner Logistics
Ensuring donors are seated with the right amount of space and social distance. The agent validates the plan to make sure no table is over capacity.

## Benefits

- Stop manual shuffling: Use execute_seating_algorithm to instantly arrange hundreds of guests without moving names one by one.
- Eliminate social friction: Ensure enemies stay apart automatically by setting proximity rules for specific individuals.
- Spot bottlenecks: Get clear feedback on which guests make a plan impossible to execute so you can fix the rules quickly.
- Audit plans quickly: Use verify_integrity to double-check a plan for errors before you print the final seating cards.
- Scale your events: Handle 500-person galas as easily as 50-person dinners with the same logic engine.

## How It Works

The bottom line is you get a conflict-free seating plan without the manual guesswork.

1. Provide a guest list, table capacities, and the rules for who cannot sit near whom.
2. The engine calculates a valid arrangement that respects all social and space constraints.
3. You receive a confirmed seating plan or a list of guests causing a logic bottleneck.

## Frequently Asked Questions

**Can the Enemy Avoidance Seater handle large weddings?**
Yes. It is designed to handle large guest lists by calculating optimal seating for hundreds of people while respecting all your social rules.

**How does the Enemy Avoidance Seater handle people who hate each other?**
You simply define them as enemies and set a minimum table distance. The engine then ensures they are never placed close enough to cause issues.

**Can I check if my current seating plan is okay?**
Yes. You can input your existing plan and the tool will audit it to confirm that no capacity limits are exceeded and no social rules are broken.

**What happens if my seating plan is impossible?**
The tool will identify exactly which guests are causing the bottleneck. This helps you see which rules you might need to relax to make the plan work.

**Can I set specific table sizes?**
Absolutely. You provide the available tables and their specific capacities, and the tool ensures every guest is seated in a valid spot.

**Is this good for corporate events?**
It is ideal for corporate galas and conferences where you need to manage large groups and ensure specific people are not seated together.

**How does the tool handle conflicts between guests?**
The tool uses a `minDistanceTables` parameter. If set to 1, enemies cannot share a table or be at adjacent tables. The `execute_seating_algorithm` checks this for every placement.

**What happens if a valid seating arrangement cannot be found?**
If the algorithm fails, it returns an 'IMPOSSIBLE' status and provides a detailed error message listing the specific guests that are causing the bottleneck.

**Can I verify an existing seating plan?**
Yes, you can use the `verify_integrity` tool to audit any proposed assignment against your table capacities and enemy constraints.