A database your agent can actually use
Dosirak embeds an MCP server that gives your agent typed tools for reading and writing records. You turn on access one project at a time, then decide table by table and field by field what the agent can reach.
What an MCP database is
Model Context Protocol (MCP) is a standard for connecting AI agents to external tools and data sources. An MCP server exposes typed operations (read a schema, query records, add a row) that an agent calls directly instead of parsing text or scraping a UI.
An MCP database is a structured data store that an agent accesses through this protocol. Instead of dumping facts into loose markdown files where keys drift, formats break, and nothing sorts, the agent works with typed fields, validated records, and relational links. For more on why this matters, see why your AI agent needs a database, not more markdown files.
Dosirak embeds an MCP server inside the desktop application. The agent reads the same schema and works with the same records the operator sees in the forms and lists.
One kernel, two ways in
The desktop app and the MCP server run the same command layer. When you add a record in the form, it goes through the kernel. When the agent adds a record over MCP, it goes through the same kernel.
This means the agent cannot do anything the app cannot show you. Every record the agent creates appears in your lists and forms. Every field the agent updates shows in the activity log.
The transport runs locally: stdio for headless operation, or HTTP on localhost when the desktop app is running. It does not go through a cloud relay, and there are no API keys or rate limits.
What the agent can do
The MCP server exposes tools that mirror the kernel's commands.
Reading a project:
list_projectsreturns the projects you have turned access on for, and nothing else.list_tablesandlist_fieldsreturn a project's tables and one table's field definitions.list_recordsandquery_recordsread records with filters, sorting, and pagination.read_recordreturns one record, including values pulled along its lookup paths.export_recordswrites records to a CSV file in your Downloads folder and returns the path.
Writing records:
create_recordadds a record with typed field values, and can create and link a related record in the same transaction.update_recordchanges fields on an existing record.delete_recordremoves one.plan_delete_recordreports what the delete would cascade to before you allow it.plan_record_changesandapply_record_changesrun a batch as a dry run first, so the agent reads the errors and the before-and-after values before anything is written.
Building and designing:
create_table,create_field, andcreate_relationshipbuild the schema.create_region,assign_field, andcreate_viewlay out the forms, the lists, and the print layouts.- Build and Design each have their own switch on the project, separate from the table rules.
Which of these an agent can actually call depends on the rules you set on the project. Every tool call is logged in the activity feed either way, so you can review what the agent read and what it changed.
What the agent is allowed to touch
A project is closed to MCP until you turn access on for it, and an agent that asks about a closed project gets nothing back. Turn it on and the project is open: the agent can read, create, edit, and delete records in every table, and it can change the structure and the layout. You tighten it from there.
Every table has its own rules for read, create, edit, and delete, and a field can override read, create, and edit. Deny delete on the invoices table and the agent can no longer remove a row. On the field where you keep a client's home address, deny read, and the agent gets the record without that value. The rules sit on the project rather than on the client, so every agent you connect sees the same thing.
Every rule has a third setting: ask. With ask, the call never reaches the database. It waits as a request showing the client, the record, and the exact fields it wants to change, and you approve it or reject it in the desktop app. With allow, the call goes through and appears in the activity log for you to read after the fact. Which tables are worth gating is your call: most people gate the ones that cost money to get wrong.
One thing Dosirak cannot do is police what the agent gets up to elsewhere. If your agent also has an email tool, sending mail is between you and that tool. Dosirak governs its own database, not the rest of your agent's toolbox.
Connect an agent
- Open Dosirak.
- Open the project once.
- Select Agent > MCP Setup.
- Turn on access for the project.
- Select Clients.
- Select your client.
- Copy the command or configuration.
- Do the remaining steps shown in Dosirak.
Keep Dosirak open while the client connects. Dosirak installs the bridge and creates the correct setup for your system.
Get Dosirak
Mac: $24.99 once
Windows: $24.49 once, 15-day free trial
There is no subscription and no account. Your records stay in a folder on your computer.
Questions
What is MCP?
Model Context Protocol is an open standard for connecting AI agents to external tools and data sources. It defines how an agent discovers available tools, calls them, and receives structured results. Dosirak uses MCP to let agents read and write records in the database.
Which agents work with Dosirak?
Any MCP-compatible client: Claude Desktop, Claude Code, Cursor, and local LLM setups that support the protocol. The server uses standard stdio transport.
Can the agent delete records?
Yes, if you let it. Delete is allowed by default, the same as read, create, and edit. Set delete to deny on a table and the tool fails for that table, or set it to ask and each delete waits for your approval in the desktop app.
Does the MCP server require an internet connection?
No. The MCP server runs locally on your machine, connecting to the same SQLite database the desktop app uses. The agent itself may need internet for its own operation, but the database connection is entirely local.
Can I use multiple agents at the same time?
Yes. The MCP server accepts concurrent connections, and all operations are transactional. The rules belong to the project rather than to the client, so every agent you connect gets the same access.
What can an agent reach by default?
Nothing, until you turn on MCP access for a project. After that the project is open: the agent can read, create, edit, and delete records in every table, and change the structure and the layout. You tighten it from there. Every table has its own rules for read, create, edit, and delete, a field can override read, create, and edit, and any of those can be set to ask so the call waits for your approval.
Do my records get sent to an AI provider?
The database itself never leaves your disk, and Dosirak has no account and no sync. But a cloud agent such as Claude Desktop works by sending what it reads to its provider, so the records it can read do travel. Denying read on the tables and fields you want to hold back is how you control that, and a local model keeps everything on the machine.
Do I need an agent at all?
No. Dosirak is a full database on its own. Forms, lists, records, relations, and printing all work with nothing connected. MCP is there for when you want the typing done for you, and you supply and pay for the agent yourself.