From Pydantic Model to AI Agent in 10 Lines of Python

Leo Pessoa — Sun, 10 May 2026 13:18:35 +0000

You've been doing this for a while now:

response = client.chat.completions.create(
    model="gemini-2.0-flash",
    messages=[{"role": "user", "content": f"Extract the following fields from this text: {fields}. Text: {text}"}]
)
data = json.loads(response.choices[0].message.content)
proposal = Proposal(**data)

Parse the response. Hope the JSON is valid. Add a retry. Add a fallback. Add validation. Repeat for every model in your app.

There's a better way.

Meet exomodel

exomodel is an open-source Python framework that turns your Pydantic models into autonomous agents. Instead of writing prompts that produce objects, you define the object — and it fills itself.

The paradigm shift:

Old way	exomodel way
Write prompt → parse response → validate	Define schema → call `.create()`
Manual JSON extraction	Native Pydantic validation
One prompt per model	Provider-agnostic, reusable
Fragile string parsing	Structured output, always

Let's build something.

Prerequisites

Python 3.9+
An API key from any supported provider (Google, Anthropic, OpenAI, Cohere)

Install

pip install "exomodel[google]"
# or: exomodel[anthropic] | exomodel[openai] | exomodel[cohere] | exomodel[all]

Create a .env file:

MY_LLM_MODEL=google:gemini-2.0-flash
GOOGLE_API_KEY=your-key-here

The 10 lines

from exomodel import ExoModel

class Proposal(ExoModel):
    client: str = ""
    project_title: str = ""
    budget: float = 0.0
    timeline_weeks: int = 0
    summary: str = ""

p = Proposal.create("Draft a proposal for Tesla — AI dashboard integration, 6 weeks, $45,000 budget")

print(p.to_ui(format="markdown"))

That's it. Run it.

## Proposal

**Client:** Tesla
**Project Title:** AI Dashboard Integration
**Budget:** 45000.0
**Timeline (weeks):** 6
**Summary:** A 6-week engagement to design and integrate an AI-powered...

exomodel sent your natural language input to the LLM, mapped the response to your schema, validated it with Pydantic, and returned a typed Python object. No prompt engineering. No JSON parsing.

Add business rules with RAG

What if your proposals need to follow company rules — minimum budget, forbidden industries, mandatory margins?

Create a proposal_rules.md file:

# Proposal Rules

- Minimum project budget is $10,000.
- Every proposal must include a 10% safety margin in pricing.
- We do not work with companies in the tobacco industry.

Now attach it to your model:

class Proposal(ExoModel):
    client: str = ""
    project_title: str = ""
    budget: float = 0.0
    timeline_weeks: int = 0
    summary: str = ""

    @classmethod
    def get_rag_sources(cls):
        return ["proposal_rules.md"]

The model now has context. You can validate against your own rules:

p = Proposal.create("Draft a 5k proposal for Philip Morris")

print(p.run_analysis())
# → This proposal violates company policy: budget below $10,000 minimum
#   and client operates in the tobacco industry.

The LLM grounded its reasoning in your document, not its training data.

Update fields with natural language

Already created a proposal but the client changed the scope?

p.update_object("Increase the budget by 20% and extend the timeline to 8 weeks")

print(p.budget)          # 54000.0
print(p.timeline_weeks)  # 8

Or update a single field:

p.update_field("summary", "Make it more formal and concise")

Bulk creation with ExoModelList

Need to generate multiple structured objects at once?

from exomodel import ExoModel, ExoModelList

class LineItem(ExoModel):
    name: str = ""
    quantity: int = 0
    unit_price: float = 0.0

class Invoice(ExoModelList[LineItem]):
    pass

invoice = Invoice()
invoice.create_list("10 MacBook Pros at 2499, 5 Dell monitors at 599, 3 mechanical keyboards at 189")

print(invoice.to_csv())

name,quantity,unit_price
MacBook Pro,10,2499.0
Dell Monitor,5,599.0
Mechanical Keyboard,3,189.0

How it works under the hood

When you call .create(), exomodel:

Introspects your Pydantic schema (field names, types, defaults)
If get_rag_sources() is defined, chunks and indexes those documents into an in-memory vector store
Builds a structured prompt with your schema and any RAG context
Sends it to your configured LLM provider
Validates the response against your Pydantic model
Returns a typed instance — with usage tracking built in

Everything goes through LangChain under the hood, so provider-switching is a one-line .env change.

Expose methods as agent tools

Need the LLM to call methods on your object, not just fill fields? Use @llm_function:

from exomodel import ExoModel, llm_function

class Proposal(ExoModel):
    client: str = ""
    budget: float = 0.0
    discount: float = 0.0

    @llm_function
    def apply_discount(self, percentage: float):
        """Apply a percentage discount to the budget."""
        self.discount = percentage
        self.budget = self.budget * (1 - percentage / 100)

p = Proposal.create("Draft a 50k proposal for Tesla")
p.master_prompt("Apply a 15% discount for a long-term partnership")

print(p.budget)    # 42500.0
print(p.discount)  # 15.0

master_prompt lets the LLM autonomously decide which tool to call — no routing logic needed.

Token usage

print(p.get_usage())
# {'prompt_tokens': 312, 'completion_tokens': 87, 'total_tokens': 399}

What's next

Docs: https://exomodel.ai
GitHub: https://github.com/exomodel-ai/exomodel
PyPI: pip install exomodel

If this saved you from writing another prompt parser, give the repo a star — it helps more developers find it.

Have a use case you'd like to see covered? Drop it in the comments.

DEV Community: Leo Pessoa