36 projects

Décroche is a voice simulator for sales teams. Give it your company's website: it reads your offer and writes the calls your reps actually face, from a price request to an unhappy customer or a cold call. Every practice call comes with its client context: who the prospect is, their company, the CRM-style record you have in front of you, and three objectives. Then you rehearse the call out loud with an AI prospect. They have a private brief (budget, decision-maker, objections) and their own files: a calendar, support tickets, orders, contracts, emails, whatever fits their business. Ask about an incident and they check their records and quote them. Propose a meeting and they open their calendar and book it. Mention last week's call and they remember it. It's up to you to ask the right questions and find out what matters to them. When you hang up, an AI coach scores the call against your company's sales scorecard, reveals the brief with what you missed and the question that would have found it, and quotes your exact words to explain the feedback. Managers can track practice and scores across the team. Have a real meeting coming up? Give Claude the email thread and it creates a practice scenario in Décroche over MCP, with that client's real context. You take the call in Décroche and review the interactive debrief in Claude through an MCP App. Three Symfony AI agents write scenarios, play prospects with their own tools, and coach reps. The prospect's replies are streamed and voiced sentence by sentence with Kyutai Pocket TTS running locally. Décroche is built with Symfony 8.1 and PHP 8.5, runs with Docker Compose, and supports English and French. It works with open models on Hugging Face or any OpenAI-compatible API.

Understand what your vibe-coded app is doing. No code reading or endless prompting required.

AI doesn't always have to be about productivity. It can also be fun. Draw It If You Can is a drawing and guessing game you play with an AI, taking turns. When you draw, the AI watches your sketch grow and shouts out one word at a time, like a friend around the table. When the AI draws, you guess: a Symfony AI agent picks up the pencil and draws live, stroke by stroke, with the wobble of a human hand. Bring your own agent along over MCP: Claude Code, Mistral Vibe or any client whose model sees images joins from the lobby, picks itself a funny nickname, and plays as your copilot or races you to the answer in a duel. Plug in the model you like, on OpenAI, Anthropic, Mistral, or locally with Ollama. A strong model draws a whale you recognise in ten seconds, a weak one a kangaroo nobody will ever guess, and both are fun. This may be the first time you want a decent graphics card for something other than 3D games, so that local models can sketch for you without burning money on every token.

"Kabbout" is how Tunisian cafés say capot: winning every single trick, usually followed by loud celebration. Kabbout is a belote contrée table where you play in your browser, 2 vs 2, with three AI agents: one is your partner, the other two would love to kabbout you. The catch: nobody can cheat. The rules live in pure PHP, not in a prompt. Bidding, legal plays and scoring are exposed as MCP tools with the PHP MCP SDK, and each seat is a Symfony AI Agent that only sees its own hand, plays through tool calling and justifies every bid in one sentence, like any self-respecting café player. Try an illegal card and the engine says no, however confident the model sounds. Clone, run one command, play: no API key needed, built-in bots take the seats until you plug in a model. Any MCP client can pull up a chair too. Mint tea not included.

Ask your AI assistant for a podcast episode about anything you like. The assistant plays editor-in-chief: it finds the sources, asks the studio for a draft over MCP, and goes through the script with you. The studio is a Symfony app: a writer agent turns the brief into a dialogue between two AI hosts, each line is voiced to match its emotion, and the episode lands in a real podcast feed with chapters and a transcript. Listeners can also ask the hosts a question by voice, and the hosts remember past episodes. Built on the MCP Bundle and PHP MCP SDK, an AI Bundle agent, structured output, Voxtral for speaking and listening, and embeddings in Postgres. Two pull requests to symfony/ai came out of it, #2873 and #2894. It's deliberately a showcase: the same building blocks could just as well power interactive stories, release podcasts or language lessons.

FormBridge lets an AI assistant fill out the forms your Symfony application already uses. Add one PHP attribute to an existing form handler, and FormBridge exposes the form as an MCP tool. It builds the tool’s input schema from the form’s fields, choices, and validation constraints, then returns Symfony’s own validation messages so you only maintain one set of rules. In clients that support MCP Apps, the person sees the prefilled form right in the conversation. Symfony renders it with Twig and shows each error next to the field it belongs to. The assistant fills in the details, and the person reviews, edits, and submits the form. The application’s existing handler saves it as usual. Other clients get a link to open the same form in a browser.

An MCP server built with Symfony AI that lets Claude Code, Cursor or any MCP client search your production logs, trace one, request across services, and write a root-cause report from the evidence

asdscccssssaaa

Give AI coding agents direct, token-efficient access to Symfony Web Profiler data via MCP—enabling Claude Code and Cursor to autonomously diagnose bottlenecks, refactor PHP code, and verify performance gains before and after every change.

NextStep MCP turns any Symfony Workflow or state machine into an MCP server where an AI agent only sees the tools that are valid right now. Each transition in your workflow becomes an MCP tool automatically, and when the state changes the server tells the client its tool list has changed: once an order moves from paid to shipped, “refund” disappears and “request return” appears. Workflow guards stay in PHP, so the agent cannot skip a step however it is prompted, and a call that is not valid for the current state is refused with the list of transitions that are. Transitions that need a human detail, such as a refund reason or a confirmation, ask for it through MCP elicitation, and the current state and a live diagram of the workflow are exposed as an MCP resource. Built as a reusable bundle on symfony/workflow, symfony/mcp-bundle and the official PHP MCP SDK, with a demo order workflow that runs from a clone in one command and needs no API key.

pen testing a

PHP2Symfony AI is an AI-powered tool that helps developers migrate existing legacy PHP applications, built with frameworks like Zend or native PHP, to modern Symfony. It analyzes the existing code, identifies dependencies, and generates a structured migration plan to simplify and accelerate modernization.

Emagma Agent Backend turns Sylius, the Symfony-based open-source e-commerce platform, into an AI-operable back-office, built with Symfony AI and the official PHP MCP SDK. It is not only a wrapper: tools cut the round trips an agent makes to the store’s APIs, which a bundled plugin optimizes over API Platform to return only the data the agent needs, saving tokens. Access control is ready out of the box: a Keycloak adapter plugs into the MCP authorization flow, so user roles decide which tools each person can see and call. When the client supports elicitation, the server asks for missing details or confirmation before sensitive operations. Third-party plugins can expose their own tools through an extension point, and yours register as Symfony services. Open source under the MIT license.

Allowing an AI agent to use an application is not the same as a person approving a specific change. Verified Human Approval lets applications require a real person to approve important MCP actions before they happen. Built on symfony/mcp-bundle, mcp/sdk, and symfony/ai-agent, it holds selected tool actions until the authorized user verifies and approves the change, and records cryptographic evidence of the approval.

MyGenoTree’s AI assistant turns typed or dictated family stories into structured family-tree updates, answers questions using existing records, and lets users preview and confirm proposed changes. Symfony AI’s Agent component manages the conversation and calls native PHP tools to search people, read family context, and prepare validated updates. Input processors supply the relevant tree context and invoke a separate moderation agent that returns structured assessments. The Platform component, through its Generic bridge, connects both agents to an OpenAI-compatible model endpoint, while the cache-backed Message Store temporarily retains conversation history and pending proposals. AI Bundle wires the models, agents, prompts, and tools into Symfony, and MCP Bundle exposes the tree tools to authorized external AI clients.

DevOps AI Investigator is an AI-powered incident investigation system built with Symfony AI and the official PHP MCP SDK. It uses Gemini to investigate application and infrastructure health through read-only MCP diagnostic tools, gathering evidence from application logs, PostgreSQL, Redis, and historical incident records. Its agent dynamically selects diagnostic tools, analyzes their responses, and generates structured investigation reports with evidence-backed findings, confidence levels, probable root causes, and recommended next steps. Investigations are persisted in PostgreSQL and can be retrieved, filtered, and explored through CLI commands. The project demonstrates how Symfony AI and MCP can turn an LLM into an evidence-driven DevOps investigation assistant while keeping infrastructure diagnostics read-only.

Any agent (Claude Code, Cursor, VS Code, Zed) runs shell commands through one MCP server. Each command is checked before it runs: - Asked in your own client. A risky command returns an MCP elicitation form, which you answer with once, this session, always for this project or refuse. The MCP bundle signs the request state, and Airlock ties it to that exact command with a one-use token. An answer for `make test` can't be reused to run anything else. - Read like a shell would. A grant for `make test` doesn't cover `make test; rm -rf ~`. `sudo`, recursive deletes, `git push` and `curl | sh` are always asked. - Run in a sandbox (bubblewrap on Linux, sandbox-exec on macOS). Commands can write only inside the project and can't read your keys. The network reaches package registries and the hosts you allow. - Output checked by a model through `symfony/ai-platform`, using structured output (`clean` or `injection`). Secrets in the output are masked, and every command goes into one audit log. Built on `symfony/mcp-bundle` (`mcp/sdk`), `symfony/ai-platform` and `ai-bundle`. It installs with one command and has a working demo in five minutes.

A read-only MCP server, written in PHP on the official PHP MCP SDK (mcp/sdk), that answers email deliverability questions from Mailcow/Postfix logs. Five tools: provider_reputation (accept/defer/bounce rates per receiving provider), top_deferral_reasons, bounce_breakdown, recent_rejections, and log_source_info. Runs over stdio or Streamable HTTP. A bundled anonymized sample log (8,944 lines) lets it run straight from a clone; 59 PHPUnit tests included.

You run the company, your employees are all AI agents. Define your company structure, hire agents with specific roles, chain of command, instructions, and have them do the work.

Your Symfony tools, on demand. Your application stays in control. Symfony Code Mode exposes two MCP entry points: search_tools discovers approved capabilities, and execute_tools invokes them with JSON. Adding tools keeps the advertised interface fixed; agents retrieve individual contracts when needed. We started with sandboxed PHP in gVisor, letting agents join and filter results before returning them to the model. To simplify adoption, we made JSON calls to existing Symfony handlers the default, running over ordinary authenticated HTTP. Discovery now builds on Symfony AI’s proposed BM25 search components. The demo shows an agent discovering an article reader and retrieving its title. Revoke permission, and the identical follow-up is denied before the handler runs, even though the agent already knows the contract. A fresh search hides it. Built with Symfony AI and the PHP MCP SDK, with shared Security voters, Maker scaffolding and profiler traces. Real agent footage and a separate Hugging Face Inference Providers conversation show the actual calls, permission checks and measured usage.

FlyNotes is a collaborative game where humans and AI agents exchange messages through virtual paper planes. Symfony AI creatively reinterprets each user’s message based on their emoji, while Sky Pulse, an internal AI agent, uses tools to carry out missions and publish results as new planes. Human-in-the-Loop workflows let users approve reinterpretations, authorize tools, and confirm results before publication. Through MCP, external AI agents can also discover messages, launch planes, and leave stamps. Try it yourself! 👉 https://flynotes.vitaminatech.com ✈️

Whether you're building a RAG chatbot that answers questions from your own data or a customer service agent that performs complex tasks, accuracy, reliability, and performance are critical. However, LLMs are inherently unpredictable, and as agents grow more complex with additional tools, context, and instructions, maintaining consistent behavior becomes increasingly challenging. Even a small change to a system prompt can introduce unexpected failures or affect previously working scenarios. Evolve is an AI-powered agent evaluation and optimization platform built with Symfony AI and MCP that addresses this challenge by letting AI coding agents like Claude Code and Codex autonomously test, evaluate, and improve other AI agents. Developers can create an agent or provide an existing system prompt, configure tools, supply dynamic context and test scenarios, and define both hard constraints (such as mandatory tool calls or execution order) and soft evaluation criteria, where an LLM judge assesses the complete execution path, decision quality, and outcome. Developers can set optimization goals for accuracy, performance, and cost, including model-specific success targets. Coding agents then iteratively refine system prompts, execute tests, analyze detailed traces, and use independent AI judges to score results and recommend improvements, while checking for regressions. A comprehensive dashboard provides visibility into execution traces, evaluation scores, token usage, costs, and prompt version history, making it easy to compare iterations and identify the most effective configuration. By automating evaluation, regression testing, and prompt optimization, Evolve transforms agent development from trial and error into a measurable, repeatable process where AI agents continuously help improve other AI agents.

PII Radar finds where a legacy PHP application stores, logs and leaks personal data, in minutes instead of weeks. Deterministic scanners read the database schema and the code. Then a Symfony AI agent, helped by a Hugging Face NER model and a RAG index of the codebase, confirms each field, traces its flows (collected, stored, logged, sent to a third party) and flags security issues with ready-to-apply Symfony fixes. The result is a privacy map, a draft data-processing register for Quebec’s Law 25 or the GDPR, and an MCP server, so any coding assistant can ask “where does the patient’s email live?” or “am I allowed to log this field?” before writing a line. The LLM only ever sees metadata, never personal values, and the whole stack can run locally with Ollama.

When an AI agent can refund, email or delete, its rules can’t live in its prompt: a persuasive user talks the model out of them. Tool Guard puts the rules in code, on the tools themselves, with the same PHP attributes for Symfony AI agent tools and for MCP tools: #[Granted] (Symfony Security voters, with a tool argument as subject — on MCP tools too, beyond per-tool OAuth scopes), #[Limit] (numeric ceilings: deny, or hold for a human above a threshold), #[RateLimit] and #[RequiresApproval]. Each agent also has its own role: a call runs only if the user and the agent are allowed, so the boss’s support assistant still cannot export every customer. Below the limits the agent acts alone. A refused call never runs and the model is told why in plain words; a held call waits for the app owner, who is told through Symfony Notifier (Slack, Teams, Telegram, email, SMS) or by a phone push, and approves or rejects the exact arguments, never text written by the model. Every call and decision goes to a hash-chained journal, so a deleted attempt breaks the chain. Works with symfony/ai-bundle, symfony/mcp-bundle and the PHP MCP SDK. The demo runs in one command with a scripted hostile agent, no API key needed, and the same attack can be played against a real model (gpt-oss-120b on Hugging Face).

aer1-php: a PHP 8.4 implementation of AER-1, the execution receipt format for AI agent tool calls defined by IETF Internet-Draft draft-zambo-aer1-26. It runs the full published AER-1 conformance corpus (143 vectors, 146 checks), and its computed evaluated-set digest matches the published digest. Receipts let anyone verify that a saved record of an AI agent's work has not changed since it was saved.

Synapse is a small second-brain demo on Symfony AI 1.0 beta, and it is also a tutorial series: five parts, each one a branch of the tutorial repository, published step by step. A capture agent files raw text into an inbox or, when it is clear knowledge, into a folder of Open Knowledge Format notes; every file access goes through one small Vault class that decides which paths exist. A read agent answers from the notes with RAG. The brain is then exposed as an MCP server with symfony/mcp-bundle behind an external authorization server, with read and write roles mapped to Symfony roles, and in the last step one instance asks a second brain over MCP while a Cohere reranker ranks both answers together. It runs on symfony/ai-agent, the AI Bundle, the MCP SDK and Cohere. The submitted repository is the optimised and improved result of the series; the step-by-step version lives in the tutorial repository.

A unified desktop toolkit that brings symfony/ai-bundle and the official PHP Model Context Protocol (MCP) SDK to native cross-platform applications via NativePHP. It turns any Symfony desktop app into an autonomous MCP server exposing STDIO JSON-RPC tools, resources, and Twig-templated prompt definitions directly to local AI agents (such as Claude Desktop or Cursor). Built with Symfony 8, it combines typed output DTOs, reactive UI events, and OS-level capabilities—including native toast notifications, system clipboard read/write, global keyboard shortcuts, and file dialogs—allowing AI agents to interact directly with the operating system in pure, idiomatic PHP.

First time participating in a Hackaton, so project will be used as a Hackaton template.

FixIt is an Android app that helps you fix everyday stuff like a coffee machine, a bike or a lamp. Snap a photo, describe what’s wrong, and it asks you a few questions before suggesting safe things to try, or telling you to call a pro. It’s Laravel on NativePHP, so it runs fully on the phone with your own API key and no backend. The AI side is all Symfony AI. symfony/ai-platform packs the photo and the conversation into a MessageBag, with the picture sent as Image content. symfony/ai-agent runs each diagnostic turn. The Symfony AI bridges for OpenAI, Anthropic, Hugging Face and Generic (any OpenAI-compatible API) let you pick the model in settings.

SaveMyPlant is a plant doctor for home gardeners, built with Symfony AI and the PHP MCP SDK. Snap a photo of a sick leaf and a vision model identifies the likely disease, a RAG store of hand-written disease sheets suggests a natural treatment, and live weather data from Open-Meteo warns you when conditions favour an outbreak in the coming days (e.g. late blight on tomatoes after humid nights). The same capabilities are exposed as an MCP server — diagnose_plant, disease_risk, sowing_calendar and companion_plants — so any MCP client, from Claude Desktop to a custom agent, can ask "what should I sow this weekend in Lyon?" or "is my garden at risk this week?" and get grounded answers.

Satisfy is a web UI over Satis for hosting private Composer packages with more than 10,000 installs. We use it extensively but it has not been updated from version 3.7 in more than 2 years. Our team is in the process of migrating to modern Symfony and releasing a 4.x version. Branch 4.x-mcp adds two plugins. The mcp plugin runs symfony/mcp-bundle, on the PHP MCP SDK, inside Satisfy at /admin/mcp behind a bearer token, with read-only tools for the repositories in satis.json and for the build queue and log. The diagnosis plugin listens for failed builds, keeps a copy of the log with credentials redacted, and has a symfony/ai-agent agent on symfony/ai-generic-platform, run without the Composer credentials, find the cause with tools that search that log and read satis.json; its answer is the MCP resource satisfy://build/diagnosis. Tested against Hugging Face's router with openai/gpt-oss-120b. Building it turned up symfony/ai#2846 and #2847, with fixes proposed in #2848 and #2849.

A code review interface for developers who accept AI can be useful, yet still read the code. After week's worth of AI work, there is a lot to review, even if you provided guidance at every step. Slopmower lets you ask questions, call out slop, request changes and provide guidance to your agent. Slop keeps growing, so it needs mowing.

Give Intakt a spec, and it runs AI agents through the work until every change is built, reviewed and merged. You set the rules, not code: which models build, who reviews, how many must agree, when a stronger model steps in, how fast the budget burns. Swap providers anytime, and tune the policy from what actually happened. Built on Symfony AI's Platform, Agent and Store, with the PHP MCP SDK opening the loop to any agent.

Attempt to simplify you personal finance and budget management with the help of Symfony AI. Automated statements parsing and categorization with decision models. "Bring Your Own Subscription" - use your ChatGPT subscription to power your agent. Want to see how much you payed for Netflix this year - agent got you covered! Just ask what you want to know about your finances and get nice and colorful reports.

An afternoon in a cemetery taking pictures produces a photo album of gravestones. Running them through an AI pipeline turns pictures into data. Wrapping the data in an agent tells a story. https://memorialatlas.org/