"Talk to your database in plain English" is one of those pitches that sounds like magic until you ask the follow-up question nobody wants to ask: talk to it how, exactly, and with whose permissions.
That question matters more now than it did a year ago. With the Model Context Protocol (MCP) becoming a common way to connect AI agents to real systems, a growing number of teams are wiring language models directly into Postgres, MySQL and SQL Server instances that used to be reachable only through vetted application code. The interface changed. The underlying access control mostly didn't. And that gap is where the interesting risks live.
A connection string is not a new kind of door
When you connect a database to an MCP server, whether through Hutif or any other tool, what actually gets configured is a connection string: host, port, database name, and credentials for a specific user or role. That's it. There's no separate "AI access tier" baked into the database engine itself, at least not yet in most setups.
This means the AI doesn't get some novel, AI-shaped set of permissions. It inherits exactly what that database user is allowed to do. If the credentials belong to a role with read and write access to every table, the AI has read and write access to every table. If the role is scoped to three views and nothing else, that's the entire world the model can see.
This sounds obvious once stated, but it's easy to lose sight of in practice. Teams often reuse an existing "app user" credential because it's convenient, the same one an internal dashboard or reporting tool already uses. That credential was scoped for a specific, predictable client. An AI agent is not a predictable client. It interprets natural language and decides what to query based on that interpretation, which is a fundamentally different risk profile than a fixed dashboard running the same five queries every day.
Seeing the schema is not the same as having free rein
There's a distinction worth being precise about: an MCP server typically exposes the database schema, table names, columns, relationships, so the model understands what it's working with. That's necessary for the AI to be useful. It is not the same thing as giving the model unrestricted query execution.
What the model can actually do depends on how the connection is configured:
- Read-only versus read-write. A database role can be restricted to SELECT statements only, which eliminates an entire category of risk (no accidental UPDATE or DELETE from a misread prompt).
- Table or schema whitelisting. Some setups let you expose only specific tables or views, keeping sensitive ones (billing details, internal audit logs) out of reach entirely.
- Query limits. Row limits, timeouts and query complexity caps prevent a single conversational request from turning into a query that locks a production table for ten minutes.
None of these are automatic just because you're using MCP. They have to be configured, either at the database level (the safest and most durable option, since it holds regardless of which tool connects) or at the layer of whichever service manages the connection. If a product doesn't give you granular control here, or defaults to full read-write access "for convenience," that's worth treating as a red flag, not a feature.
What a conversational layer doesn't fix
Even with tight permissions, there are problems that access control simply doesn't touch.
The first is interpretation. A model can generate a syntactically correct query that answers the wrong question. Ask "what were our top customers last quarter" and the answer depends on definitions the AI can't infer on its own: does "top" mean revenue or order count, does "last quarter" mean calendar or fiscal, does "customers" include churned accounts. Get any of that wrong and you get a confident, well-formatted, incorrect answer. This isn't a security failure. It's a plain accuracy risk, and it's arguably the more common one in daily use.
The second is cost. A read-only role protects your data's integrity, but it doesn't protect your database's performance. A poorly scoped query against a large, unindexed table can still be expensive to run even if it can't modify anything. Query limits and timeouts help, but they're a mitigation, not a guarantee.
The third is scope creep over time. Access that seemed reasonable when a team connected one reporting table tends to expand as more use cases get added, often without anyone revisiting whether the original permissions still make sense.
Where this leaves a product like Hutif
Hutif's job is to make connecting a database or a file to an AI agent fast and code-free. That's a real convenience, but it's worth being direct about what that convenience does and doesn't include.
What the architecture aims to provide: each connection is isolated, and where the underlying database supports it, you can configure read-only access and restrict which tables are exposed before generating a link. What it does not and cannot provide: a guarantee that the credentials you enter are properly scoped in the first place. If you connect a database user with broad write access because that was the easiest credential to grab, no MCP layer, from Hutif or anyone else, will retroactively narrow that for you.
That responsibility sits with whoever sets up the connection, and it's the same responsibility that existed before AI agents entered the picture, just with a new client on the other end asking the questions.
A practical starting point
Regardless of which tool sits between an AI agent and a database, a few habits hold up:
- Create a dedicated database user for the AI connection rather than reusing an existing app credential.
- Default to read-only unless there's a specific reason the agent needs to write.
- Whitelist tables explicitly rather than exposing an entire schema by default.
- Set query timeouts and row limits at the database level when the engine supports it.
- Review the connection periodically, the same way you'd review any API key with standing access to production data.
None of this is exotic. It's the same discipline that's applied to any system with programmatic database access, applied to a new kind of client that happens to talk in sentences instead of fixed queries. The novelty of the interface doesn't change the fundamentals underneath it. If anything, it's a reason to be more deliberate about them, not less.