aluseg-mcp
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@aluseg-mcpwhich tenants are late on rent this month?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Aluseg MCP Server
An open-source, self-hostable Model Context Protocol server for rental management.
Aluseg MCP lets AI assistants (Claude, local LLMs, custom agentic workflows) securely interact with a landlord's own rental data — leases, rent status, tenant records, tax-authority filings — through a standard, auditable interface, instead of ad hoc scraping or fragile custom integrations.
It is built security- and privacy-first: every tool call is made on behalf of one authenticated user, scoped to exactly that user's permissions, and recorded in an immutable audit log — never through a single over-privileged service account.
Status: Early development. The tool specification and reference implementation are under active work. See the roadmap.
License: AGPL-3.0 · Standard: Model Context Protocol (JSON-RPC 2.0)
Why this exists
Rental-management platforms today are closed boxes. Landlords who want their AI assistant to answer "which of my tenants are late on rent this month?" or "draft a lease for this new tenant" have no clean, safe way to connect it — the data is locked behind a web UI with no API, or behind a closed, paywalled one never designed for AI agents.
At the same time, most Model Context Protocol servers connect to business systems using a single master service account — convenient for a developer's laptop, but unacceptable for a multi-tenant SaaS handling regulated personal and financial data. One leaked token, and an AI agent can read or act on every account.
Aluseg MCP addresses both gaps:
Open & self-hostable. Released under AGPL-3.0 as a standalone, containerized service. Any landlord, property manager, or developer can run it against their own data — independent of Aluseg's hosted infrastructure. No vendor lock-in.
Per-user authority, not a master key. The AI agent authenticates as a specific user via OAuth 2.0 and can only ever do what that user is allowed to do.
Safe by default on regulated actions. High-stakes tools (generating a legal contract, filing with the tax authority, initiating a payment) are gated by attribute-based access control and explicit, human-in-the-loop consent.
Related MCP server: stessa-mcp
Architecture
Aluseg MCP is a decoupled gateway. It exposes MCP tools to AI clients and translates them into authenticated calls against a rental-management backend — it never talks to a database directly, and it holds no platform-wide credentials.
+-----------------------------------------------------------------------+
| LLM / AI Client |
| (Claude Desktop, Cursor, custom agentic workflows) |
+-----------------------------------------------------------------------+
|
| JSON-RPC 2.0 (stdio / SSE)
v
+-----------------------------------------------------------------------+
| Aluseg MCP Server |
| - Exposes tools to AI agents (verify_parties, generate_lease, ...) |
| - Stateless, containerized, self-hostable (OCI image) |
| - Per-user OAuth 2.0 auth + ABAC policy + immutable audit log |
+-----------------------------------------------------------------------+
|
| Authenticated HTTPS (user-scoped token)
v
+-----------------------------------------------------------------------+
| Rental-management backend API |
| (Aluseg SaaS, or any backend implementing the open tool schema) |
+-----------------------------------------------------------------------+Because the server is decoupled and stateless, it can run anywhere — a landlord's own machine, a small VPS, or alongside the backend — supporting data portability rather than central dependency.
Exposed tools
The server exposes a small, deliberately-scoped set of tools. Each carries an explicit privacy/security constraint.
Tool | Purpose | Key inputs | Constraint |
| Verify the identity of landlord and tenant |
| Requires OAuth 2.0 auth; parses eIDAS digital signatures |
| Draft a standardized rental contract from verified metadata |
| Restricted to verified owners; returns a signable draft, never auto-executes |
| File a lease with the tax authority (AT) |
| Requires active, explicit, time-bounded user consent |
| Assess default risk and propose rent-default insurance |
| Requires explicit, time-bounded consent; GDPR-compliant, uses only permitted data |
| Read rent-payment status for a property/period |
| Read-only; scoped to the authenticated user's properties |
Read-only tools resolve to data the user can already see. Write/action tools (
generate_lease,notify_tax_authority) produce drafts or require human confirmation — the agent proposes, the human commits.
The full machine-readable tool schema lives in spec/ and is intended to be an open standard other rental backends can implement, so PropTech developers can build interoperable tools instead of reinventing incompatible integrations.
Security & privacy model
This is the core of the project, not an afterthought.
User-level OAuth 2.0 delegation. The AI agent never operates under a global API key. It presents a token tied to one landlord or tenant; the server validates it and enforces that the agent can only touch resources that specific user is authorized for.
Attribute-based access control (ABAC). Before executing a sensitive tool, the server evaluates contextual attributes (user role, document sensitivity, consent state) — not just "is this user logged in."
Human-in-the-loop on irreversible actions. Issuing a legal contract or initiating a payment always requires an explicit confirmation step. The agent cannot autonomously execute legally or financially binding actions.
Immutable audit logging. Every tool call records the user identity, tool name, input parameters, and returned data in a tamper-evident log — supporting GDPR traceability and accountability.
Data minimization. Tools return only what the task requires; risk assessment uses permitted, consented data only.
Getting started
⚠️ Not yet ready for production use. These instructions describe the target developer setup.
# Clone
git clone https://github.com/peltierclem/aluseg-mcp.git
cd aluseg-mcp
# Configure (backend URL + OAuth client credentials)
cp .env.example .env
$EDITOR .env
# Run with Docker
docker compose up
# ...or run locally
npm install
npm run devThen register the server with your MCP client (e.g. Claude Desktop) by pointing it at the server's stdio command or SSE endpoint. See docs/clients.md (coming soon).
Roadmap
Publish the open MCP tool specification (
spec/)Reference server: JSON-RPC transport (stdio + SSE)
OAuth 2.0 per-user authentication
ABAC policy engine for sensitive tools
Immutable audit logging
Read-only tools (
get_rent_status, party lookups)Action tools with human-in-the-loop (
generate_lease,notify_tax_authority)Containerized release (OCI image) + self-hosting guide
Submit to public MCP server directories
Contributing
Contributions, issues, and discussion are welcome. Please open an issue to discuss significant changes before submitting a pull request. By contributing, you agree your contributions are licensed under AGPL-3.0.
License
Licensed under the GNU Affero General Public License v3.0 — see LICENSE.
AGPL-3.0 is deliberate: because this is a network service, anyone who runs a modified version as a hosted service must also publish their modifications. This keeps the MCP server and its security patterns an open commons, while leaving separate backend implementations that merely call this server over the network unaffected.
Acknowledgements
This work is developed in the context of the Next Generation Internet initiative, which supports an open, trustworthy, and human-centric internet.
Available Tools
5 toolsgenerate_leaseA
Draft a standardized rental contract from verified party and property metadata. Always returns a draft for human review — never auto-signs.
| Name | Required | Description | Default |
|---|---|---|---|
| duration | Yes | ||
| rent_value | Yes | ||
| oauth_token | Yes | ||
| property_id | Yes | ||
| parties_verified_id | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of disclosure. It explicitly states the tool never auto-signs and always returns a draft, which is a key behavioral trait. It does not mention side effects or storage, but the main safety-relevant behavior is transparently disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the primary action and a clear safety qualifier. Every word adds value, with no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 required parameters, no output schema, and no annotations, the description provides a solid overview of the tool's function and its human-in-the-loop aspect. It lacks details on auth token usage or error behavior, but the core purpose and immediate outcome are sufficiently clear.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% parameter description coverage, so the description must compensate. It hints at 'verified party' and 'property metadata' corresponding to parties_verified_id and property_id, but it does not explain oauth_token, duration format, or rent_value semantics beyond the schema type. Partial compensation only.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool drafts a standardized rental contract using verified party and property metadata. The verb 'draft' and resource 'rental contract' are specific, and it is clearly distinct from sibling tools like verify_parties and get_rent_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description indicates the tool consumes verified party and property metadata, implying it should be used after verification. It also clarifies that it never auto-signs, leaving room for human review, which is a workflow guideline. However, it does not explicitly name alternative tools or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_rent_statusA
Read rent-payment status for a property over a given period. Read-only, scoped to the authenticated user's properties.
| Name | Required | Description | Default |
|---|---|---|---|
| period | Yes | ||
| oauth_token | Yes | ||
| property_id | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It explicitly discloses 'Read-only' and 'scoped to the authenticated user's properties,' which are key behavioral and authorization traits. It does not describe return format or edge cases, but for a read operation this is reasonably transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the action and resource, and contains no filler. Every clause adds value: 'Read rent-payment status for a property over a given period' states purpose, and 'Read-only, scoped to the authenticated user's properties' adds constraints.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of the tool and the absence of an output schema, the description covers the essential context: what it does, scope, and read-only nature. It does not elaborate on the content of the status response, but the core selection and invocation needs are addressed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description adds meaning to 'property_id' and 'period' by mentioning 'property' and 'a given period.' 'oauth_token' is self-explanatory. This partially compensates for the lack of schema descriptions, but period format and property identification details remain unspecified.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Read') and resource ('rent-payment status') and clearly scopes it to a property and period. It distinguishes itself from sibling tools like generate_lease and notify_tax_authority, which have different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description states 'Read-only, scoped to the authenticated user's properties,' which provides clear context on when to use it (for read-only queries) and its authorization scope. It does not explicitly name alternatives but the distinction from siblings is obvious.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
notify_tax_authorityA
Submit a signed lease to the Portuguese Tax and Customs Authority (AT). Requires explicit, time-bounded landlord consent.
| Name | Required | Description | Default |
|---|---|---|---|
| oauth_token | Yes | ||
| consent_token | Yes | ||
| at_credentials_token | Yes | ||
| signed_contract_hash | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses a key behavioral requirement (landlord consent) but lacks other behavioral details such as side effects, irreversibility, or response format. Since there are no annotations, the description carries the full burden and only partially fulfills it.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, consisting of two short sentences that directly convey the purpose and a key prerequisite. No redundant information is present.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 4 required parameters, no output schema, and no annotations, the description is minimal. It does not explain the auth tokens, the meaning of 'time-bounded consent', or what happens on submission, leaving the agent with insufficient information to use the tool confidently.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description should explain each parameter. It only implicitly touches on consent_token via the consent requirement, leaving oauth_token, at_credentials_token, and signed_contract_hash unexplained. This does not compensate for the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('Submit a signed lease') and the target resource ('Portuguese Tax and Customs Authority (AT)'), distinguishing it from sibling tools like verify_parties or generate_lease.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides context by noting the prerequisite of explicit, time-bounded landlord consent, implying when the tool should be used. However, it does not explicitly mention alternatives or when not to use it, preventing a higher score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
propose_unpaid_insuranceA
Assess tenant default risk from consented data and return unpaid-rent insurance quotes.
| Name | Required | Description | Default |
|---|---|---|---|
| oauth_token | Yes | ||
| monthly_rent | Yes | ||
| tenant_consent_token | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description bears the full burden of behavioral disclosure. It mentions 'consented data' but does not explain the tool's side effects, whether it is read-only, how the OAuth token is used, or what happens with the data. The description is too vague about the operational behavior and limitations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence that immediately states the action and the result. It is well-front-loaded with 'Assess tenant default risk' and contains no unnecessary words or filler, making it efficiently concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema and no annotations, so the description must convey enough context for correct invocation. It explains the high-level function but does not specify the return format or any edge cases (e.g., invalid consent, failure modes). For a moderately complex tool with three required parameters, this is only minimally adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no parameter descriptions, and the description does not elaborate on the parameters. While names like 'monthly_rent' are somewhat self-explanatory, 'tenant_consent_token' and 'oauth_token' are not fully explained. The description mentions 'consented data' but does not clarify the role of each parameter, leaving the agent to infer too much.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Assess tenant default risk from consented data and return unpaid-rent insurance quotes.' It uses specific verbs ('assess', 'return') and identifies the resource (tenant default risk, insurance quotes). This distinguishes it from sibling tools like verify_parties, generate_lease, notify_tax_authority, and get_rent_status, which serve different functions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool: when you need to assess a tenant's default risk and obtain insurance quotes. It implies the need for consented data, which suggests a prerequisite, but does not explicitly state when not to use it or name alternatives. The context is clear, though no exclusions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
verify_partiesC
Authenticate and verify the identity of the landlord and tenant.
| Name | Required | Description | Default |
|---|---|---|---|
| tenant_nif | Yes | ||
| oauth_token | Yes | ||
| landlord_nif | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full behavioral burden. It only states the action and does not disclose side effects, failure behavior, required permissions, or the nature of the verification process. This is a significant gap for a tool that could have side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words. It fits the tool's simplicity and is front-loaded with the core action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has three required parameters and no output schema, the description is too thin. It does not explain what verification entails, how the parameters are used, or what response to expect. This would leave an agent underinformed for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description mentions none of the three parameters (landlord_nif, tenant_nif, oauth_token). It adds no meaning beyond the raw schema, so the agent has no guidance on what these values represent or how they are used.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses specific verbs ('Authenticate and verify') and clearly names the resource ('the landlord and tenant'). It distinguishes this tool from siblings like generate_lease or get_rent_status by focusing on identity verification, which is a unique action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives. The description implies it is for identity verification, but there are no explicit when/when-not instructions or references to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
5 tool updates
v0.1.0- First observed
generate_lease - First observed
get_rent_status - First observed
notify_tax_authority - First observed
propose_unpaid_insurance - First observed
verify_parties
TDQS
Each tool targets a distinct step in the rental workflow: identity verification, lease drafting, tax notification, insurance quoting, and rent status reading. There is no functional overlap between them.
All tool names follow a consistent verb_noun pattern (verify_parties, generate_lease, notify_tax_authority, propose_unpaid_insurance, get_rent_status) with clear, descriptive verbs and snake_case formatting.
With 5 tools, the server is well-scoped for a focused lease-management domain. Each tool earns its place and covers a necessary step without unnecessary bloat.
The server covers the core lifecycle from party verification and lease generation to tax submission, insurance quotes, and rent status. Minor gaps exist (e.g., no lease signing or update tool), but the intentional human-review step mitigates this.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
MCP server connecting AI agents to 100+ apps (Gmail, Slack, Notion, GitHub) via one-click OAuth.
Governed property-management MCP: portfolio, leasing, accounting, maintenance, OAuth 2.1.
Zero-setup MCP gateway securely connecting AI to your tools with authentication and workflows
MCP server that lets AI assistants use all OneSchema features exposed via the public API.
Related MCP Servers
AlicenseNot gradedqualityCmaintenanceMCP server for the Rentalot API. Manage rental properties, contacts, showings, conversations, and more from any AI assistant.141MIT- AlicenseNot gradedqualityDmaintenanceMCP server for Stessa rental-property accounting platform, enabling AI agents to query properties, portfolios, banking, documents, and tenancies via natural language.MIT
- FlicenseNot gradedqualityCmaintenanceMCP server that enables AI assistants to securely access and manage personal financial data from Inntektsportalen (Norwegian income portal) with fine-grained scope-based authorization via OAuth2.-
- AlicenseAqualityBmaintenanceMCP server that lets an AI assistant perform scoped Okta identity operations with an out-of-band human-approval gate on destructive actions.5MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/peltierclem/aluseg-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server