r/FastAPI

So this idea started with chatbots like Gemini, ChatGPT and Claude. When I would use them for school work, and would upload my school documents, I would always get incorrect answers or simply confusion.

So this project started as a simple solution for AI to do my schoolwork and now it is called Parseflow, and today I published it. So how it works is when you send in a document, Parseflow will process it and extract all the information within and organize that data to return structured chunks, which can be used directly or can be searched through with the search features. By using Parseflow, you can improve context and reduce token costs. Currently it accepts PDFs, DOCX files and plain text.

I am still a student, graduating high school this year, so I built this project to try pay for university. I still have a lot to learn so any feedback, advice, questions, etc... are appreciated, you can DM me if you need.

I'm developing a side project and trying to follow DDD principles as closely as possible. My current structure is router -> service -> repository. I'm using SQLAlchemy for ORM models, which are created and handled in the repository layer.

Right now, I convert those ORM objects into Pydantic models inside the service layer, and then pass those models to the router, which returns them in the response. I'm wondering whether this is the right approach or if there’s a better pattern for handling the conversion and data flow between layers.

Coming from ExpressJS, I’ve been loving how fast and easy FastAPI is. In my Node ecosystem, I usually use Prisma with PostgreSQL, which means I don't strictly need separate models for data i/o. While I can define validation schemas (like Zod) if needed, it’s not forced on a model-by-model basis. If it's a non-mission-critical project and I know what's in the payload, I can skip validation entirely.

But in FastAPI, it feels like I'm forced to maintain two separate models: a Pydantic model for request/response validation, and a SQLAlchemy model for the database.

Does it always have to be this way? Can it just be a single model, and what is the actual industry standard here?

Want to learn fast api project wise visit the fast api offical site but what I want is how to structure fastapi app

api calls

database connection

models

authentication flow

third party interaction

needs appropriate resources

What’s a good admin dashboard for FastAPI? I have a bunch of project ideas I plan on working on in the next few months and I don’t want to be building out a dashboard for each of them. I’ve done some research and while there are some decent ones out there I wanted to see what the community had to say.

a friend who invests in rental properties kept asking me to look up data on houses he was considering. zestimate, price trend, rent estimate, school ratings. he'd text me an address and i'd go manually check zillow. after the 50th time i figured i'd just build him something.

the backend is fastapi. i'm pulling property data from a rest api called zillapi that returns zillow data as json. 300+ fields per property. the fastapi part is what i want to talk about because dependency injection made this project way cleaner than i expected.

i set up the api client as a dependency. a single function that initializes the http client with the bearer token and base url. every endpoint that needs property data just declares it as a parameter. no global state, no passing clients around manually, no import spaghetti.

my main endpoints:

GET /property/{address} → full property summary
GET /compare?addresses=addr1&addresses=addr2 → side by side comparison
GET /cashflow/{address}?down_payment=25 → rental investment analysis

the cashflow endpoint is the one my friend uses most. it takes the rent estimate and asking price from the api response, calculates the mortgage at current rates, and returns monthly cash flow at whatever down payment percentage you pass in. the whole endpoint is about 30 lines including the response model.

pydantic response models were the other win. the raw api response has 300+ fields but i only need about 20 for the frontend. i defined a PropertySummary model with just the fields i care about and fastapi handles the filtering automatically. the response is clean typed json that my react frontend can trust. no extra serialization code, no manual field picking.

i also added background tasks for the comparison endpoint. when you compare 3-4 properties it makes multiple api calls. instead of doing them sequentially i use asyncio.gather so they all fire at once. comparison of 4 properties takes about 2 seconds instead of 6-8.

for the ai feature i set up a skill so he can also ask claude about properties:

npx clawhub@latest install zillow-full

the whole thing runs on a $5/month vps. my friend has been using it every morning for about a month. he checks 10-15 properties before he starts his actual job.

Hi everyone,

Like many of you, I’m using Claude Code and Cursor daily. But I got tired of constantly correcting the agent because it didn't "know" my project’s specific patterns, leading to hallucinated APIs and broken boilerplate.

I’m working on FastKit Core — a meta-framework for FastAPI designed to be "Agent-Friendly" from the ground up.

The Philosophy: Instead of the AI guessing how you structure your services, DTOs, or events, FastKit ships with a pre-configured AI_CONTEXT.md.

How it works:

You reference AI_CONTEXT.md in your CLAUDE.md or .cursorrules.

1. The agent instantly understands the entire architectural layout.
2. You can prompt: "Create a new CRUD module for 'Book' with async events" and it actually gets the imports and patterns right the first time.

Key Features of FastKit Core:

• Production-Ready Patterns: Built-in support for asynchronicity, clean architecture, and standardized response formats.
• Zero Hallucinations: Every snippet in the context file is verified against actual source code.
• Meta-Framework approach: It doesn't replace FastAPI; it standardizes it so you can focus on business logic while the AI handles the scaffolding.

I’m looking for early adopters to try it out, break things, and give feedback on the DX (Developer Experience).

Check it out here:https://fastkit.org/docs/fastkit-core

Repo:https://github.com/fastkit-org/fastkit-core

Would love to hear your thoughts on "AI-native" project structures. Is this the future of how we'll build frameworks?

The copy feature available in Swagger UI only copies the endpoint URL. That’s why I built a Chrome extension that captures all the details of an endpoint and copies them in Markdown format.

You can even copy all endpoints under an entire tag with a single click. Since the output is in Markdown, it can be used to generate API documentation or pasted directly into ChatGPT, Claude AI, and other AI platforms for further processing.

Like: https://github.com/AsiF-Py/Swagger-UI-Copy-Full-Details-Endpoint-Extension