Simafri Suite
Professional email, calendar, contacts and files on your own domain.
| Endpoint | https://suite-mcp.simafri.com/mcp (streamable-http) |
|---|---|
| Registry version | 1.0.0 |
| Now | 68 tools · grade D (64) · pin ts_61a100babaf445784b419f4570158c4a · protocol 2025-06-18 |
| First / last listed | 2026-10-27 03:16 UTC / 2026-10-27 03:16 UTC |
| Grade over time | 2026-10-27: D (64), 68 tools |
Is this your server? Own a server? ToolFit hosted watch re-checks it every 24 h ($0.25 per 30 days) or 6 h ($0.60) and sends you an HMAC-signed webhook when its tools or grade change: POST https://api.youraitools.co/toolfit/v1/watch. To opt out, see About & opt-out.
Tools: list_conversations search_conversations get_conversation get_customer_card get_attachment create_attachment_upload send_email reply_to_conversation forward_conversation list_drafts approve_draft reject_draft list_compose_drafts save_compose_draft delete_compose_draft list_scheduled_sends cancel_scheduled_send set_conversation_status assign_conversation unassign_conversation add_note rename_conversation merge_conversation file_conversation list_folders create_folder update_folder delete_folder delete_conversation report_spam mark_not_spam unsubscribe list_blocked_senders unblock_sender list_suppressed_recipients remove_suppression mark_read mark_unread poll_mailboxes list_sender_addresses set_signature set_archive_on_reply list_mailboxes add_mailbox_holder remove_mailbox_holder add_mailbox_alias remove_mailbox_alias list_people invite_person add_queue_operator remove_queue_operator list_teams create_team rename_team delete_team add_team_member remove_team_member list_brands list_contacts get_contact create_contact update_contact list_knowledge create_knowledge update_knowledge delete_knowledge get_settings set_auto_draft
list_conversations | Lists threads, most recently updated first, with the contact, the subject of the mail and the one the team gave the thread ("team_subject", null until rename_conversation gives one), the ticket number of a helpdesk case (what the client quotes, null on somebody's mailbox), the status, where the thread stands in the pipeline, who is handling it, whether a draft is waiting for review, the folder eac params: status, channel, brand, box, folder, unread, external_ref, assignee, team, limit, before |
search_conversations | Finds the threads of one mailbox by their subject, their text, the people on them or the names of the files they carried, best answer first. Call list_sender_addresses to find the box. This is how you look a mail up when you know a word of it and not where it is. params: box*, q*, folder, limit |
get_conversation | Reads one thread whole: every message in order with its direction, its language and its attachments, the contact fiche, the mailbox the thread arrived through, the draft awaiting review when there is one, and in "notes" what the team left on the thread for each other, oldest first, with who wrote each one. Notes are never part of "messages" and were never sent to anyone. A message the mailbox sent params: conversation_id* |
get_customer_card | Reads the customer card of a helpdesk ticket: what the account's own system (its client area, CRM or ERP) knows about the correspondent, asked live by their address, such as their account, their services and when they renew, and what they owe. "status" says "found" with the card, "not_found" when that system does not know them, "unavailable" when it did not answer (ask again later, it says nothing params: conversation_id* |
get_attachment | Reads a file attached to a message and gives back its CONTENT. Text comes back as text, whatever the sender labelled it: a CSV, an XML, a JSON, a Markdown or a log read as text even when they arrive as application/octet-stream. An image comes back as the image itself, a PDF comes back as the text it holds, which is how an invoice, a quote or a contract is read, and a .gz or a .zip is opened to giv params: conversation_id*, attachment_id* |
create_attachment_upload | Opens an address to send a file to, so that a message can attach it without carrying it. Answers with an upload_id and an upload_url: PUT the bytes to that address in one request (no key, nothing to sign, for example `curl -T report.pdf "<upload_url>"`), then pass {"upload_id": "..."} in the "attachments" of send_email, reply_to_conversation, forward_conversation or approve_draft. This is the way params: filename*, content_type |
send_email | Writes and sends an email to someone, and opens the thread their answer will land in. The text goes out as given, so this is the tool for a message a person has read and approved. With "send_at" it is scheduled instead: nothing leaves until then, and list_scheduled_sends shows it waiting. params: from*, to*, cc, bcc, subject*, body*, contact_name, attachments, send_at |
reply_to_conversation | Sends an answer in an existing thread, written by the caller, from the address the thread arrived through. A draft left pending on that thread is superseded, so the contact reads one answer. With "send_at" the answer is scheduled instead, and supersedes that draft only when it leaves. params: conversation_id*, body*, reply_all, cc, bcc, attachments, send_at, status |
forward_conversation | Passes the last message of a thread on to someone else: they receive the text quoted under its own header, with the files it carried attached again. Their answer opens a thread of its own, so forwarding to the account support address is how a message reaches the support queue, in that direction only. params: conversation_id*, to*, cc, bcc, note |
list_drafts | Lists the answers Iris has written, with the thread each belongs to, the contact it goes to and the text as it stands. Filter on "pending_review" for the review queue. params: status |
approve_draft | Sends a draft to the contact, with the text as given in "body" when you edited it. The draft keeps the original wording and the sent message keeps what actually left, so the two stay comparable afterwards. params: draft_id*, body, attachments, status |
reject_draft | Turns a draft down and sends nothing. The thread stays open for another answer, by Iris or by a person. params: draft_id*, reason |
list_compose_drafts | Lists the messages begun on the account addresses and never sent, last written first, with their recipients, subject, text and files. These are unsent texts, not the answers Iris wrote for review, which list_drafts holds. params: address |
save_compose_draft | Writes down a message being prepared, so it can be finished later from anywhere. Pass "from" to start one; pass its id to write into it again, where the fields you leave out keep the value they had. Saving sends nothing: send_email is what sends. params: draft_id, from, to, cc, bcc, subject, body |
delete_compose_draft | Throws away a message that was started and will not be sent. Nothing was ever delivered, so nothing is lost but the text itself. params: draft_id* |
list_scheduled_sends | Lists the messages given a "send_at" that have not left yet, soonest first: when each leaves (in the zone of the person you act for), from which address, to whom, the subject and text, and the thread an answer goes into. A message that has left is no longer here but in its thread. One that could not leave stays, with state "failed" and the reason, until it is cancelled. params: address |
cancel_scheduled_send | Calls a scheduled message back before it leaves. Nothing is sent and nothing is lost: it becomes an unsent draft again, with its recipients, text and files, whose draft_id the answer gives (delete_compose_draft throws it away). Refused once the message is already leaving. params: scheduled_send_id* |
set_conversation_status | Says where a thread stands, and optionally where it stands in the pipeline. Both are recorded as decided by a person, so a later reading by Iris keeps them. To set the same status on several threads, give conversation_id the list of their ids, in ONE call rather than one call per thread: the answer then lists in "results" the outcome of each thread in the order given ("ok", with its "result" or it params: conversation_id*, status*, deal_stage |
assign_conversation | Puts a colleague's name on a thread of a helpdesk queue: what says, to everyone working that queue, that this one is being dealt with and by whom. It hands over the WORK and not the access, so the thread stays readable by the whole team and nobody loses sight of it. Somebody who does not work that queue is refused rather than named on a thread they cannot open, and so is a deactivated account: put params: conversation_id*, person, team |
unassign_conversation | Takes the name off a thread: nobody is handling it, and it goes back to the queue for whoever picks it up. It closes no door, the thread having been readable by everybody working that queue the whole time. Replayed on a thread nobody had taken, it answers the same thing. To give several threads back to the queue, give conversation_id the list of their ids, in ONE call rather than one call per thre params: conversation_id* |
add_note | Leaves a note on a thread for the people who work it: shown on the thread screen beside the messages, marked as internal, and in "notes" of get_conversation. It never reaches the correspondent: it is not sent, not quoted in a reply and not part of the mail. It is where the context goes when you hand a thread to a colleague, what you found, what was agreed, why you stopped. It does not change the s params: conversation_id*, body* |
rename_conversation | Gives a thread a subject that says what it is about, for the people who work it: shown in the lists and on the thread screen in place of the subject of the mail, and in "team_subject" of list_conversations and get_conversation. It is the team's label and never the subject of the correspondent's mail: "subject" stays the one they wrote, every answer still leaves as a "Re:" of it with the ticket num params: conversation_id*, team_subject* |
merge_conversation | Merges a helpdesk ticket into another of the same contact, for the client who wrote again beside their case rather than in it. Everything it held moves to the ticket named by "into": its messages, their files, its notes, its drafts. Its number keeps leading to the merged case, so the client's next reply quoting it lands there. The ticket merged away is gone, a note on the one that stays says so (w params: conversation_id*, into*, note |
file_conversation | Files a thread where you say: "archive" puts it away, out of the Inbox and kept for good; "trash" throws it away, where it stays readable and can be brought back; "inbox" brings it back from wherever it was; or "folder_id" files it in a folder a person made (list_folders gives them), which becomes its home. One thread sits in one place, so filing it somewhere takes it out of where it was; a reply params: conversation_id*, folder, folder_id, status, deal_stage |
list_folders | Lists the folders the people of a mailbox made in it, beside the six every mailbox has (inbox, sent, drafts, spam, trash, archive), each with its id, its name, its full path ("Clients/LCS") and its parent. The ids are what list_conversations, search_conversations and file_conversation take, and what update_folder and delete_folder act on. params: box* |
create_folder | Makes a folder in a mailbox, at the top or under another folder, to file threads in. Every holder of the box sees it, in the webmail and in their mail client. A name holds no "/", "*" nor "%", is unique among its neighbours, and at the top is none of the six every mailbox has. params: box*, name*, parent_id |
update_folder | Renames a folder a person made, moves it under another one or to the top, or both; the folders under it follow, and the threads in it stay. What you leave out keeps its value. params: folder_id*, name, parent_id |
delete_folder | Deletes a folder a person made and the folders under it. Their threads go to the Trash, where they stay readable and restorable for 30 days; nothing is deleted for good. The answer says how many went there. params: folder_id* |
delete_conversation | Deletes a thread and everything it holds: every message, the drafts written on it, and the files that came with them, down to the bytes they were stored as. This is FINAL and there is no trash to fish it back out of, so it is not the gesture for tidying an inbox: file_conversation with "trash" is, and it keeps the thread readable and restorable. Use this only when the record itself must not remain params: conversation_id* |
report_spam | Moves a thread of a mailbox into its Spam folder, where it stays readable and can be taken back out, and blocks its sender: their next message is filed in Spam too, without anybody being asked again. Spam is emptied 30 days after a thread lands there, and that deletion is final. Threads of a helpdesk queue have no Spam folder and are refused: file_conversation with "trash" throws them away instead params: conversation_id* |
mark_not_spam | Puts a thread the filter or someone else filed as spam back into the Inbox of its mailbox, and unblocks its sender. A thread that is not in Spam is left where it is, and nothing is unblocked. To take several threads out of Spam, give conversation_id the list of their ids, in ONE call rather than one call per thread: the answer then lists in "results" the outcome of each thread in the order given ( params: conversation_id* |
unsubscribe | Leaves the mailing list a thread came from (a newsletter, a promotional mailing, a notification list), in the name of the mailbox it arrived in, with what the last message received in the thread offers: one POST to the list's unsubscribe address when it accepts a one-click unsubscription, otherwise a short mail from the box to the list's own address. get_conversation says, in "unsubscribe" on each params: conversation_id* |
list_blocked_senders | Lists the addresses whose mail this account files straight into Spam, most recently blocked first, with the day each was blocked. A block is what report_spam leaves behind, so this is where a rule the account is living under becomes visible again: a sender blocked from a thread long since deleted appears here and nowhere else. params: none |
unblock_sender | Lets an address write to the Inbox again: their next message is filed like anybody else's. Threads already sitting in Spam stay where they are, a block having always been about the mail still to come; file_conversation with "inbox" is what brings one of them back. An address this account holds no block on answers that there was nothing to lift. params: address* |
list_suppressed_recipients | Lists the addresses that pressed "this is spam" on this account's mail, with the day and the label their provider gave it. The account writes to none of them, and it does so SILENTLY: a message to one of these addresses is stopped before it leaves, with no bounce and nothing in the thread to see. So this is the list to read when a mail seems to have gone nowhere and nothing said why. params: none |
remove_suppression | Takes an address off the list above, so this account can write to them again. Weigh it before calling it: the row means a person pressed "this is spam" on mail from this account, and writing to them again is what turns a complaint into a sending reputation the whole platform shares. Call it when there is a reason to believe they want to hear from this account again, said by them, and not merely be params: address* |
mark_read | Clears the bold on a thread for YOU, exactly as opening it on screen does: a colleague reading the same shared mailbox keeps their own. Reading a thread with get_conversation does not do this by itself, on purpose: fetching a mail is not the same as having read it. A message arriving after this call turns the thread bold again. To clear the bold on several threads, give conversation_id the list of params: conversation_id* |
mark_unread | Puts a thread back among the bold rows, for you alone: what you want to come back to. A colleague sees no change. To put several threads back among the bold rows, give conversation_id the list of their ids, in ONE call rather than one call per thread: the answer then lists in "results" the outcome of each thread in the order given ("ok", with its "result" or its "error") and counts "succeeded" and params: conversation_id* |
poll_mailboxes | Reads the account mailboxes right away instead of waiting for the next scheduled round, and answers with what came in. Call it when you expect a message that has not appeared yet. params: none |
list_sender_addresses | Lists the inbound addresses of the account, each with the block that closes what is written from it and, for a mailbox, the other names that deliver into it. Sending from any of these is what brings the answer back into the mailbox. params: none |
set_signature | Writes the block that closes what is written from an address. It belongs to the address, so everyone who writes from it signs the same way; it is put into a message when one is being written, not added behind the sender back. params: address*, signature* |
set_archive_on_reply | Says whether a thread of a mailbox leaves the Inbox for the Archive as soon as the box answers it, whether the answer is written in the webmail, through these tools or in a mail app such as Thunderbird. The thread comes back to the Inbox when a new message arrives in it. A setting of the box: on a box held by several people it moves the thread for all of them. A helpdesk queue refuses it, its thre params: address*, archive_on_reply* |
list_mailboxes | Lists the mailboxes of the account: each one with the people who hold it, the other names that deliver into it and the storage its plan entitles the account to, which every box of it shares. It says who is on a box, never what is in one. params: none |
add_mailbox_holder | Puts a person of the account on a mailbox, which is what lets them read it. This is how a company takes back the correspondence of someone who has left; it is recorded, and the box shows it to whoever is on it. A box may be held by several people. params: address*, person* |
remove_mailbox_holder | Takes a person off a mailbox: they stop reading it from that moment. Nothing is deleted, and a box left with no holder keeps receiving and keeps everything it holds. Recorded like the other direction. params: address*, person* |
add_mailbox_alias | Points another address at a mailbox: mail sent to it lands in that box, threads there and counts against the storage of the account. An alias has no password, no seat and no storage of its own, and the number one box may carry is limited; list_mailboxes gives the limit and what is already used. params: address*, alias* |
remove_mailbox_alias | Stops an address delivering into a box. What already arrived through it stays in the box, and each message still says which name it came in on. params: address*, alias* |
list_people | Lists everyone on the account: how they sign in, the rank they hold, and how far they see into the mail. An owner and a manager work every helpdesk queue, which is said as works_every_queue; anyone else works the queues named on them and nothing else. It says who works where, never what any of it holds. A rank is not written from here: for a client of Simafri Suite it is held at the shop and resta params: none |
invite_person | Opens an access for a colleague without a password: an invitation goes to send_to, and whoever opens it chooses the password from its link, which opens for seven days and once. The link is never shown here, you included, and the record names where it went. send_to is the person themselves at an address they already read, or the box of whoever sets up the team's access. A mailbox of this platform i params: email*, name, send_to*, role, locale |
add_queue_operator | Names a person of the account on a helpdesk queue, which is what lets them work it: they see the threads that arrived on that address, and none of the others. This is how a shared queue is split between colleagues, one department to each. Somebody whose rank already opens every queue is refused rather than given a grant that changes nothing. params: person*, queue* |
remove_queue_operator | Takes a person off a helpdesk queue: they stop seeing its threads from that moment. Nothing is deleted, and a queue nobody is named on keeps receiving and is still worked by the owners and the managers of the account. params: person*, queue* |
list_teams | Lists the teams of the account, the administrative team or the technical one for instance, each with its slug (what assign_conversation and the other team tools take) and who is in it. A team is a way of handing a thread to several people at once; it opens no queue, so a member only ever sees the threads of the queues they work. params: none |
create_team | Opens a team by its name; its slug comes from the name and never changes, even when the team is renamed. A name too close to one the account already has is refused. Put people in it with add_team_member. params: name* |
rename_team | Gives a team a new name. Its slug stays, so every reference to it keeps working. params: team*, name* |
delete_team | Deletes a team. The threads handed to it go back to their queue with nobody's name on them; the threads one of its members took stay on that member's name. params: team* |
add_team_member | Puts a person of the account in a team, whatever their rank. It opens no queue: they see the threads handed to the team only on the queues they already work, which add_queue_operator decides. A deactivated account is refused. params: team*, person* |
remove_team_member | Takes a person out of a team. The threads they took from it stay on their name. params: team*, person* |
list_brands | Lists the brands of the account, its subdivisions, each with the slug the other tools take. params: none |
list_contacts | Lists the contacts of the account with their fiche, most recently seen first, and searches them by name, company or address. params: q, limit |
get_contact | Reads one contact whole: their fiche, the addresses they write from and where each field came from. params: contact_id* |
create_contact | Opens a fiche for someone before any exchange has happened. An address the account already holds returns that contact as it stands, so calling it twice keeps one fiche. params: email*, name, company_name, contact_title, phone, address, sector, project_type, language |
update_contact | Writes the fiche fields you pass, and leaves the others as they are. What is written here is recorded as coming from a person, which keeps a later reading by Iris from overwriting it. params: contact_id*, name, company_name, contact_title, phone, address, sector, project_type, language |
list_knowledge | Lists the playbook docs of the account with their full content: this is the material Iris reads before drafting, and the place to look when an answer needs to say what the house does. params: none |
create_knowledge | Adds a doc to the playbook Iris reads, scoped to the brands and addresses you give it. Use it to record a price list, an argument that works or a rule to follow, once, where every future draft will find it. params: title*, content*, brands, addresses, sort_order |
update_knowledge | Writes a doc whole, keeping the previous version dated in its history. Send the title and the content each time, plus the brands and addresses it applies to. params: doc_id*, title*, content*, brands, addresses, sort_order |
delete_knowledge | Takes a doc out of the playbook, with every version it ever had. This is FINAL and there is no trash: Iris stops reading it from the next draft on. A doc that is merely out of date is better rewritten with update_knowledge, which keeps the previous version dated in its history. params: doc_id* |
get_settings | Reads the settings of the account, starting with whether an incoming message has Iris draft an answer on its own. "own_domain_spoofs" says what the account does with a mail that shows one of its own domains and fails DMARC: "filed" when such a mail goes to Spam (to the Trash, closed, on a helpdesk queue) as it arrives, and "exempt_senders" for the addresses of the account that keep arriving normal params: none |
set_auto_draft | Says whether an incoming message has Iris draft an answer on its own. With it off, a draft is written when someone asks for one from the inbox, which is what keeps the model spend where you put it. params: auto_draft* |
Entries describe changes in tool definitions. They are not statements about a server, its quality or its author. The grade measures how the tool definitions fit model providers (token cost, schema compatibility, confusable names) as scored by the ToolFit engine at the time of the listing. JSON: append .json. Opt-out: how or hello@youraitools.co.