Sahel Memariani’s Post

Today I ran into a classic backend bug while testing my FastAPI project 🚀 Everything was working fine until login started throwing a 500 error. After debugging, I found the issue: Environment variables are always read as strings — which caused a failure in timedelta() while generating JWT tokens. A small fix (casting to int) solved it, but the learning was huge: ✔ Always validate environment configs ✔ Debugging > coding ✔ Real-world issues teach the most Also successfully: ✅ Deployed FastAPI app on Render ✅ Integrated PostgreSQL ✅ Implemented authentication with JWT ✅ Added pagination Next step: Docker + CI/CD 🔥 Live API: https://lnkd.in/gVAWNtVp #FastAPI #BackendDevelopment #Python #DevOps #LearningInPublic

Improving Retrieval Quality in RAG and Search Pipelines When retrieval quality breaks down in RAG and search pipelines, it's often due to issues at the document and context layer, long before the model layer. This is where Fincept-Corporation/FinceptTerminal comes in – a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment. Built with Python and leveraging native performance through C++20 with Qt6, FinceptTerminal provides a single binary with no Electron/web overhead, Node.js, browser runtime, or JavaScript bundler. This streamlined approach enables faster and more reliable retrieval, making it an attractive solution for developers working with RAG and search pipelines. What sets FinceptTerminal apart is its focus on the often-overlooked document and context layer. By addressing these issues directly, FinceptTerminal improves retrieval quality and reduces the likelihood of breakdowns further down the pipeline. Key benefits include: - Native performance through C++20 with Qt6 - Single binary with no additional runtime dependencies - Advanced market analytics, investment research, and economic data tools - Built with Python for flexibility and ease of use The traction FinceptTerminal is gaining makes sense: with around 1,169 new stars in the current trending window, it's clear that developers are recognizing the value of its streamlined approach to retrieval quality. As an organization account, FinceptTerminal also benefits from increased trust and distribution. Repo: https://lnkd.in/gbTzmn9k #GitHub #OpenSource #GitHubTrending #LinkedInForDevelopers #Python #FinceptTerminal #BloombergTerminal #ContributionsWelcome

I’m excited to announce the release of PyHexaGen on PyPI, the specialized tool to bring professional Hexagonal Architecture to your FastAPI projects instantly. FastAPI is amazing for high-performance development, but as projects grow, maintaining a clean separation between business logic and the API layer can become a challenge. PyHexaGen automates this by scaffolding a production-ready structure based on the Ports and Adapters pattern. Why use PyHexaGen for your next FastAPI project? - Zero-Effort Setup: Stop spending hours organizing folders. Get a structured project with domain, application, and infrastructure layers in seconds. - Clean vertical slices: Specialized scaffolding for your FastAPI endpoints, linking them directly to your Use Cases. - Better Testing: Designed to make Unit Testing your business logic easy, without needing to mock the entire FastAPI stack. - Scalability: Move from a simple POC to a complex enterprise application without the "spaghetti code" trap. Building fast is good, but building smart is better. If you are using FastAPI for production-grade services, PyHexaGen is the companion you’ve been waiting for to keep your codebase clean and maintainable. Pypi: https://lnkd.in/ejrGQF9E GitHub: https://lnkd.in/e974X8v6 Feedback and contributions are more than welcome! #FastAPI #Python #SoftwareArchitecture #PyPI #CleanArchitecture #Developers #Backend #SoftwareEngineering #PyHexaGen

I used to think backend development was complicated. Too many concepts. Too much setup. It felt difficult to move from theory to actually building something real. Then I started learning FastAPI. This time, I didn’t just watch tutorials. I focused on building. - My Journey with FastAPI As a Python developer, FastAPI felt simple, fast, and practical from the start. It helped me understand how backend systems actually work instead of just learning concepts. - Why FastAPI? - High performance - Clean and easy syntax for Python developers - Built-in validation using Pydantic - Automatic API documentation with Swagger UI - What I’ve learned - Building REST APIs using GET and POST methods - Handling request and response data - Using Pydantic for data validation - Testing APIs using interactive Swagger documentation - What I’ve built I built backend projects using FastAPI where I created API endpoints, validated data, and tested everything through auto-generated docs. This hands-on experience helped me connect theory with real-world development. Working with FastAPI has improved my confidence in backend development and made me more comfortable building practical applications. If you are learning development and feel stuck, try building something instead of only consuming content. I would love to know what you are currently working on. #FastAPI #Python #BackendDevelopment #WebDevelopment #LearningInPublic

What I love about LangChain is the spectrum of control it provides. On one end, LangGraph allows for the creation of precise, opinionated workflows with complete control over nodes, edges, and execution flow. On the other end, create_agent offers a simple ReAct loop, while the Deep Agents SDK enhances functionality with built-in planning, file systems, subagent spawning, and long-term memory — all readily available. Both ends are powerful, but there is a gap in the middle. Sometimes, a sequential structure is needed without the complexity of a full graph. Tasks should run in order, each with its own tools and instructions, while the model drives the transitions. This requires a solution that is neither a rigid pipeline nor a free-running loop, but something in between. This is why I developed 𝗹𝗮𝗻𝗴𝗰𝗵𝗮𝗶𝗻-𝘁𝗮𝘀𝗸-𝘀𝘁𝗲𝗲𝗿𝗶𝗻𝗴 for LangChain agents. With this middleware, tasks are defined as data. It scopes tools, injects instructions, enforces ordering, and gates completion, while allowing the model to decide when to progress. There are no hardcoded graph edges. Available for Python and TypeScript: 𝗽𝗶𝗽 𝗶𝗻𝘀𝘁𝗮𝗹𝗹 𝗹𝗮𝗻𝗴𝗰𝗵𝗮𝗶𝗻-𝘁𝗮𝘀𝗸-𝘀𝘁𝗲𝗲𝗿𝗶𝗻𝗴 𝗻𝗽𝗺 𝗶𝗻𝘀𝘁𝗮𝗹𝗹 𝗹𝗮𝗻𝗴𝗰𝗵𝗮𝗶𝗻-𝘁𝗮𝘀𝗸-𝘀𝘁𝗲𝗲𝗿𝗶𝗻𝗴 #LangChain #LangGraph #DeepAgents #AI #Agents #OpenSource #Python #TypeScript

🚀 FastAPI: Why It’s Becoming the Go-To Framework for Modern APIs I used to think FastAPI was just another Python framework… But after working with it, I realized it’s built for how APIs should be designed today. Here’s what makes it stand out 👇 🔹 High Performance Built on ASGI with async support, FastAPI handles high concurrency efficiently — making it ideal for real-time and scalable systems. 🔹 Automatic Validation Using Python type hints + Pydantic, it validates requests and responses automatically. Less boilerplate, fewer bugs. 🔹 Auto-Generated Docs Swagger & ReDoc come out of the box. You get interactive API documentation without extra effort. 🔹 Async Support (When Needed) Perfect for I/O-heavy tasks like APIs, DB calls, and external integrations. But also flexible enough to work synchronously. 🔹 Developer Experience Clean syntax, strong typing, and easy debugging — makes development faster and more structured. 💡 What stood out to me: FastAPI isn’t just about speed — it’s about writing clean, reliable, and scalable APIs with less effort. In a world where performance and scalability matter, FastAPI is definitely worth exploring. Curious — have you tried FastAPI in production yet? 🤔 #FastAPI #Python #BackendDevelopment #APIs #Developers #Tech #LearningJourney

Writing commits can be tedious. Review the files you changed, think about what actually happened, come up with a message that makes sense; and do that every single time you commit. It adds up. I'm a big fan of Conventional Commits, and I wanted to build something that helps people keep using it without wasting time thinking about the perfect message every single time. So I built gitai. 🚀 gitai reads your staged git diff, calls your configured LLM, and gives you 3 commit message suggestions to pick from. That's it. You stage your changes, run gitai, and it gives you something like: feat(auth): add JWT refresh token rotation Some things worth knowing: - Supports Ollama, run it fully local, no API key needed - Also works with OpenAI, Anthropic, and Gemini - Two commit styles: Conventional Commits or free-form - Optional gitmoji support - Config lives in a simple TOML file (~/.gitai.toml) It's open source, it's on PyPI, and I use it every day. pip install gitai-cli GitHub: https://lnkd.in/gEk3AYPM PyPI: https://lnkd.in/gyibCB8H If you try it, let me know what you think. PRs and issues are very welcome. 🙌 #Python #OpenSource #DevTools #Git #CLI

🚀 FastAPI: Build Powerful APIs with Less Code If you're building APIs in Python and not using FastAPI yet… you're missing out. Here’s why FastAPI is gaining massive popularity 👇 ⚡ Blazing Fast Performance Built on ASGI and Starlette, FastAPI delivers performance close to Node.js and Go. 🧠 Automatic Data Validation Thanks to Pydantic, you get type validation using Python type hints — clean and powerful. 📄 Auto-Generated Docs Swagger UI & ReDoc are generated automatically. No extra effort needed. 🔐 Easy Authentication & Security Supports OAuth2, JWT, and other modern security standards out of the box. 🔧 Developer-Friendly Less code, more productivity. You write less boilerplate and focus on logic. 💡 Example: from fastapi import FastAPI app = FastAPI() @app.get("/") def home(): return {"message": "Hello FastAPI 🚀"} 🔥 Whether you're building microservices, AI APIs, or backend systems — FastAPI is a game changer. Start learning today and level up your backend skills 💪 #FastAPI #Python #BackendDevelopment #WebDevelopment #APIs #Programming #SoftwareEngineering #100DaysOfCode #DeveloperLife #Coding

FastAPI — Why It’s Becoming a Favorite for Backend Development FastAPI is a modern Python framework used to build APIs quickly and efficiently. But it’s not just another framework. It’s designed for speed, simplicity, and performance. What is FastAPI? FastAPI is a web framework for building APIs using Python, based on modern standards like type hints. It helps developers write less code and build faster, reliable APIs. Key Features: High performance (comparable to Node.js and Go) Automatic data validation using Python types Auto-generated API documentation (Swagger UI) Built-in async support Easy integration with databases and tools Example Use Cases: Building REST APIs Backend for web and mobile applications AI/ML model APIs Microservices architecture Why developers prefer FastAPI: Clean and readable code Faster development time Strong typing reduces bugs Suitable for scalable systems Final Insight: FastAPI is not just about building APIs faster. It’s about building APIs the right way. Follow Saif Modan #Python #FastAPI #Backend #API #Tech #AI

I spent too much time reconciling logs and traces until I understood how OpenTelemetry logging actually works. 🔑 The key insight: OTel doesn't try to be your logging library. It's a bridge. Your existing logger (Log4j, Python logging, winston) keeps working exactly as it does today. But behind the scenes, an appender automatically enriches every log record with trace context — the TraceId and SpanId from the active span. ✨ That's it. That's the whole idea. And it changes everything. ⚡ Suddenly, debugging is faster. You see logs in context of their span. You see which logs caused a trace anomaly. Your backend (Jaeger, Tempo, Elastic, whatever) can now correlate logs to traces without you writing SQL joins or doing manual detective work. 📖 Just published a 16-minute technical guide walking through log formats, the unified LogRecord schema, the Logs API and SDK, processors, and exporters. Available on LearnObservability — link in comments. #OpenTelemetry #Observability #DevOps #DistributedTracing #SRE #Logging