Hugging Face

Hugging Face AI

Hugging Face AI

Hugging Face AI

Hugging Face AI

Hugging Face AI

Hugging Face AI

Hugging Face AI

Hugging Face AI

Hugging Face AI

Hugging Face AI

Update to my last Post, which aims at security for your projects, fully open source and local.

Coverage update — CodeInspectus now covers 32 checks (13 AI-specific + 19 SAST) plus 200+ secret & API-key patterns. ★ Built for AI-generated code — the checks generic scanners don't have (13) 1) Hardcoded secret shipped in client-side code 2) Secret baked into the built JS bundle 3) Real secret behind a client-visible env prefix (NEXT_PUBLIC_ / VITE_ / PUBLIC_) 4) Supabase service_role key (full DB access, bypasses RLS) in client-reachable code 5) LLM SDK client with dangerouslyAllowBrowser:true, exposing your API key 6) RLS policy with USING (true) — matches every row, table wide open 7) Public table created with no Row-Level-Security at all 8) RLS checking JWT role/aud instead of the actual user — access not scoped to owner 9) Supabase Edge Function with no auth check — endpoint runs for anyone 10) Over-permissive RLS on storage.objects — bucket files openly accessible 11) Untrusted input reaching an LLM prompt (flags likely prompt-injection sinks) 12) Authz decision trusting client-writable user_metadata — privilege escalation 13) Model/untrusted output rendered as raw HTML in React (__html) — XSS Industry-standard code security (19 SAST checks) 14) SQL injection — string-built query (JS/TS) 15) SQL injection — string-built query (Python) 16) Command injection — shell command from string (JS/TS) 17) Command injection — subprocess shell=True (Python) 18) eval / dynamic code execution (JS/TS) 19) eval / exec of non-literal (Python) 20) NoSQL injection from request data 21) Path traversal — filesystem path from request input 22) DOM XSS — untrusted data into innerHTML/outerHTML 23) SSRF — outbound request URL from request input 24) Weak hash (MD5 / SHA-1) — JS/TS 25) Weak hash (MD5 / SHA-1) — Python 26) Weak cipher (DES / RC4 / 3DES) 27) Insecure randomness — Math.random() for a security value 28) JWT alg:none — signature-check bypass 29) CORS wildcard origin with credentials allowed 30) Insecure cookie — missing httpOnly / secure 31) Insecure deserialization (Node) 32) Insecure deserialization (Python) Plus 200+ secret & API-key patterns — Anthropic, OpenAI, Google/Gemini, AWS, GitHub, GitLab, Stripe, Supabase, Cohere, Perplexity, Hugging Face, Azure + more. All still fully local. https://github.com/Synvoya/codeinspectus Requesting your valuable feedback, and support from like minded security professionals to further improve this 🙏🏽 submitted by /u/hibzy7 [link] [comments]

Fun Reddit Sim built with Claude Code

I designed the client with Claude Fable 5 (Anthropic's new Mythos-tier model), working out the UI/UX and how it should be shaped, then had Claude Opus 4.8 actually build it as a real Blazor WebAssembly app on top of an existing backend (LiteDB, a moderation layer, and an AI persona engine that generates in-character posts through Claude, OpenAI, Grok, or HuggingFace). Live: https://eternalsocial.ngrok.app Source: https://github.com/sharpninja/EternalReddit Would love feedback, bug reports, and nominations for which figures deserve their own subreddit next. submitted by /u/RealSharpNinja [link] [comments]

We open-sourced a routing gateway that cuts LLM costs 4.7x–22x by matching each query to the right model (Apache 2.0)

I'm on the team at Regolo and we just released Brick — an open-source Mixture-of-Models router that reads every prompt's capability (coding, math, reasoning, creative, planning, world knowledge) and complexity, then routes it to the cheapest model in your pool that can actually do the job. One call per query, no cascade waste. Why we built it: we kept seeing teams burn $50k–200k/month on a single frontier model because most queries are simple lookups that don't need it. No dynamic selection = flat cost no matter what you send. How it works (step by step, with a real example): Let's say you send 1,000 queries/day to Claude Opus, and that costs $165/day ($4,950/month). But here's the thing — not every query needs Opus. Here's what Brick does with those same 1,000 queries: Step 1 — Capability classification: Brick reads each prompt and classifies it across 6 dimensions (coding, math_reasoning, creative_synthesis, instruction_following, planning_agentic, world_knowledge): Step 2 — Complexity assessment: a second classifier scores difficulty as easy / medium / hard: Step 3 — Routing decision: Brick computes a skill-distance score for each model in your pool and picks the cheapest one that can handle the job. One forward pass, one decision, no cascade. Step 4 — Result: same 1,000 queries, same quality on the ones that matter — but your daily cost drops from $165 → $35/day. That's a 79% reduction, or ~$3,900/month saved. Easy to use with Claude Code or any other OpenAI Compatible provider: brick claude on # wires ANTHROPIC_BASE_URL, starts the router brick claude status # live dashboard with routing metrics Also works as a standalone OpenAI-compatible gateway (model: "brick"), with Codex, and with any client. No GPU needed for the router itself — runs on CPU. Demo video: https://youtu.be/RXnYNxYwSKQ Links: GitHub: https://github.com/regolo-ai/brick-SR1 Paper: https://github.com/regolo-ai/brick-SR1/blob/main/docs/paper/paper.pdf Demo video: https://youtu.be/RXnYNxYwSKQ Weights on HuggingFace: https://huggingface.co/regolo What I'd love feedback on: the routing logic, the benchmark methodology, and whether the Claude Code integration is something you'd actually use day-to-day. Happy to go deep on any technical detail. submitted by /u/alexgenovese [link] [comments]

I used Claude Code to build a plain-English database of local government meetings for 2,400+ US & Canadian cities

Local government is where the decisions that actually change your life get made — zoning, budgets, water rates, the $2M road contract — and almost nobody can find out what their city council is doing without sitting through a 3-hour meeting or reading a 200-page PDF. So I fixed that. https://mytown.theboringparts.com pulls council, board, and commission meetings from 2,400+ US and Canadian cities and turns every agenda into a plain-English summary. Search your town, see what it's deciding this week. What's live right now: - 60,000+ meetings across 2,400 municipalities - 45,000 AI-written briefs in plain English - 11 government-portal platforms reverse-engineered and wired up (Legistar, CivicPlus, Granicus, BoardDocs, IQM2…) — every city runs different software and none of them ship a usable API, so I built an adapter for each - Full-text search over all of it, weekly AI roundups per city, a federal sibling site, and meeting videos transcribed with whisper on a 5090 It's not AI slop, and I built it so you don't have to take my word for that: every summary links to the primary source document, and the methodology page (https://mytown.theboringparts.com/methodology/) publishes the exact prompts and the fact-first rules the models run under — fact-first, traceable, neutral, no fabrication. Every page has a "report an error" button. The whole dataset is open (CC-BY on Hugging Face). Claude Code did a ton of the build — the adapters, the pipeline, the static-site generator. Local LLMs on my own hardware do the summarization, so it runs for almost nothing. Search your city and tell me what you find. If a summary's wrong, I want to know — that's what the report button is for. submitted by /u/mrjakob07 [link] [comments]

I kept burning Claude Code limits on iterative AI work, so we made it delegate the iteration loops over MCP as a workaround. Benchmark on an identical task: $1.96 → $0.74, 37% faster inference (repo inside)

Disclosure first: I'm the cofounder/CTO of Neo, the agent in this comparison — so this is a first-party benchmark. The repo, scripts, and results are public so you can check our work instead of taking my word for it: https://github.com/gauravvij/parakeet-stt-eval Why we ran this. The thing that drains my Claude Code budget is never the hard problems — it's the iteration: run, hit an error, re-read the file, fix, run again. Every loop burns tokens. We wanted to measure how much of that cost is structural to interactive mode versus inherent to the task itself. The task. Benchmark two Parakeet STT variants (full-precision HF vs GGUF-quantized) on a CPU-only Azure VM — 2 cores, 7.7 GB RAM, no GPU — using the open-source Eval-STT framework. Neither model is natively supported, so both runs had to extend the framework with custom code. Run 1 — Claude Code, interactive. The standard workflow: prompt, watch, course-correct. It worked, and it took the obvious path — HuggingFace Transformers + PyTorch, bfloat16. Cost: $1.96. Inference speed: RTF 0.519. Run 2 — Claude Code delegating to Neo over MCP. Identical prompt except it started with "Ask Neo to…". Claude Code orchestrated; Neo spent ~2 minutes researching before writing any code — read the framework, read both model cards, checked CPU inference benchmarks — then chose ONNX Runtime over PyTorch (AVX2-optimized kernels on CPU) and Q6_K over Q4_K quantization. One batched clarifying question, then it ran unattended. Cost: $0.74. RTF: 0.328 — same model, same hardware, 37% faster purely from a better backend decision. On limits vs. API dollars. We measured on API pricing because it's the only objective yardstick, but the mechanism is identical on Pro/Max: that $1.22 gap is the token cost of interactive back-and-forth, and it's the same burn that eats your session window. Fewer iteration loops = your limits go further. This was one small task — the gap compounds on longer or repeated runs. Caveats, because you'd find them anyway: The full writeup shows a big WER improvement (20.9% → 4.65%). Ignore it — it's an artifact of test-audio generation (espeak-ng vs gTTS), not agent intelligence. Both models scored identically within each run; the audio generator was the variable. The durable findings are the cost and RTF numbers. This is n=1. One task, one machine. The narrow claim: research-before-code beats iterate-in-real-time on well-scoped ML pipeline work. Don't believe us — the repo makes it reproducible. Claude Code solo actually wrote the more analytically nuanced report. Interactive mode still wins when you're exploring a problem or need to understand the build, not just receive the output. This isn't "agent replaces Claude Code" — it's Claude Code as orchestrator for the grunt loops. On costs, to be fully upfront: Both figures are all-in, the $0.74 includes the Neo credits consumed on the run, not just Claude tokens. Neo is a paid product with a free trial. I'm deliberately not pitching plans here. This post is about whether the delegation pattern holds up, and the repo lets you judge that independently of us. Setup: pip install neo-mcp, then one claude mcp add command with your Neo access key, then just say "Ask Neo to…" in any session. Detailed write up and MCP installation Docs link is in comments below 👇 Genuine ask for this sub: what's a task where you'd bet interactive Claude Code beats delegation? Name it - we'll run both and publish the numbers either way. submitted by /u/gvij [link] [comments]

I used Claude to build a 135M looped LLM from scratch — it debugged Parcae paper implementations, caught optimizer routing bugs, wrote Modal training infra, and helped ship to HuggingFace. Here's the full story.

Built a 135M dense looped LLM from scratch. Spent 2 weeks debugging Parcae's LTI stability mechanisms across 5 ablations. None of them beat the naive baseline at this scale. Trained for real anyway. SFT'd it. Shipped it. Here's the full honest story. What I built A 135M parameter looped transformer trained from scratch on FineWeb (4.6B tokens), inspired by the Parcae paper (arXiv:2604.12946 — "Scaling Laws For Stable Looped Language Models"). 🤗 Base model: huggingface.co/harims95/LoopLM-135M-naive 🤗 SFT model: huggingface.co/harims95/LoopLM-135M-naive-sft 📂 Code: github.com/harims95/LoopLM 💰 Total cost: ~$51 (Modal H100s + free Lightning H200) Architecture Input → [Embedding] → [Prelude: 4 blocks] → e (injection) → [Loop block × T loops, T~Poisson(μ=6)] → [Coda: 2 blocks] → logits d_model 1024, GQA 16/8 heads, RoPE, QK-norm, SwiGLU FFN 2816 Update rule: h_{t+1} = block(h + e) (naive) or with LTI stability (Parcae) Muon + AdamW optimizers, truncated BPTT (μ_bwd=3), bf16 Trained on 2× H100 on Modal, ~3 hours wall clock The Parcae investigation (the interesting part) The paper claims LTI stability constraints on the recurrent state dramatically improve looped LM training. I tried to reproduce it. Here's what actually happened: AblationDescriptionVal loss1. Naive loopedh = block(h + e)3.842. + A matrixLTI decay constraint3.84 (tied)3. + Input norm v1Wrong arch flowDiverged4. + LTI before blockFixed arch, B=identityWorse5. + B→AdamW, init=0.447Matched official repoDramatically worse Every single "fix" — bringing my implementation closer to the official Parcae code — made things worse. After consulting: The paper's Appendix Q (optimizer routing) Official sandyresearch/parcae repo (injection.py) Two rounds of ChatGPT + Gemini debugging sessions My conclusion: Parcae's stability improvements are a large-scale phenomenon. The paper's 1.3B model trains for 170k+ steps before stability mechanisms kick in. At 135M / 17.5k steps, naive looped is competitive enough that the extra complexity hurts more than it helps. Comparison with sibling MoE My brother built HobbyLM — a 500M MoE on the same infrastructure. For apples-to-apples comparison, I ran naive looped 135M on the same FineWeb data: ModelArchitectureTokensVal lossLoopLM-135M (mine)Dense looped4.6B3.95HobbyLM-130M MoE (bro)Sparse MoE10B3.30 Dense looped loses to MoE at this scale/budget. Sparse MoE is more sample-efficient. Not surprising but now I have the data to confirm it. SFT results (bonus) Fine-tuned on Alpaca 52k using Lightning AI's free H200. Took 6 minutes (bf16 on H200 is insane). Before SFT: "The capital of France is a" (top predicted token) After SFT: "The French capital of France is located in the city, where it was built." Improvement in format, not in facts. At 135M / 4.6B tokens, SFT teaches format, not knowledge. The model still hallucinates — that's a base model capacity problem, not a fine-tuning problem. What I learned On Parcae: Small-scale reproductions of large-scale papers are dangerous. The paper's key contribution (stability at 170k+ steps) is invisible at hobby budgets. Naive looped is a legitimate architecture for anyone training sub-1B models. On MoE vs looped: At matched parameter count and token budget, MoE wins on sample efficiency. Looped models need more tokens to show their advantage, or need to be much bigger to amortize the loop cost. On debugging: When 3 independent LLMs (me, ChatGPT 5.5, Gemini) all agree on a fix and it makes things worse — the paper's regime assumption is probably wrong, not your code. On SFT: H200 on Lightning AI is free (2 hours/month) and runs 6 minutes of SFT for free. Use it. Colab Free disconnects at 3 hours. Don't use it for long jobs. On honest publishing: val 3.95 is not impressive. The architecture exploration is. Shipping anyway with full documentation of what failed is more valuable than hiding failures. Stack Training: Modal (H100s), Lightning AI (H200 for SFT) Framework: PyTorch, HuggingFace Transformers Optimizer: Muon (matrices) + AdamW (rest) Data: FineWeb via kjj0/fineweb10B-gpt2 shards Infra forked from: github.com/harishsg993010/HobbyLM (my brother's 500M MoE project) Happy to answer questions about any part of this. The code is fully open, reproducible, and documented. submitted by /u/Hariharanms [link] [comments]

I built an MCP for HuggingFace publish workflows and am looking for feedback before expanding it.

(Repost because I messed up on a lot of things while posting) Basically....I started out trying to fine tune my own models 2 months ago. I was sort of unsure about how to do proper model cards, tagging, etc. I used to upload models using Unsloth in my Nvidia PC or Kaggle or Colab. I am still very new to this and one day I saw codestrate/Llama3.2-3B-Claude-Reasoning-Distill getting a lot of downloads. Most people told me it was AI bots archive downloading new stuff, but after all this time it still gets attention and likes (despite it being my 3rd or 4th attempt and a bad one at that). I was motivated that despite choosing a hard skill during this bad phase of losing my job in April, I could make things that other people might like and even appreciate. Bit the Bullet and got Claude Pro with my remaining salary. Taking inspiration from the Github MCP and my personal battle with model cards and managing my models on my profile in general, I started building HF Publish this month and published it on npmjs. I used Claude Sonnet 4.6 for my coding agent who basically helped plan out the most complicated model edit tool and the later quant tool using gguf-my-repo space but didn't work out yet... npm package: https://www.npmjs.com/package/hf-publish-mcp (currently on version 1.0.3 and 450+ downloads) GitHub source: https://github.com/CodeStrate/hf-publish-mcp Now I know the official MCP for HuggingFace exists but it's a wrapper for the CLI essentially, and to be frank I didn't do a whole lot. I added the functionality to let the Agent format your model cards (like Github READMEs) and upload models on your behalf while you do something else. Here's a basic rundown of what features you may find: List and Upload List and Inspect your repos. Official MCP does that too, mine's just focused on the user's own repos, not the entire HuggingFace library. Upload Models/Adapters. So far very painless, but sometimes HF doesn't like your network so big uploads can be slow. Currently uploads can stop if the agent stops or sleeps. but local Job management ftw xd. Model Card created by CC Manage your model card. The "standout" feature I wanted to have like Github. It can do surgical small edits, big rewrites, or update your metadata, your call. There's a `dryRun` flag so destructive edits can be reviewed in a diff before you commit. Updating Model Cards I've also been working on two features to merge and quantise your fine-tuned adapter models on the cloud via Spaces, but can't get the OAuth working at all headlessly without going through the Browser route. So I have currently left it out from the package currently. Would love some help for if anyone finds the idea interesting. Model on HuggingFace (made via MCP) I have also been pondering on how to showcase the application using a demo GIF on the Github/package page, so any feedback on it would be extremely helpful. Made it with much love and care and got to learn a lot from whatever I have currently got on there. Maybe someone sharing the same sentiment would give tips? I wholeheartedly appreciate any feedback or criticism I can learn from to improve this further. submitted by /u/FlimsyCricket8710 [link] [comments]

I built an opensource Claude Code skill for Fiverr optimization since there wasn't any

Most "AI Fiverr tools" quietly tell the model to mentally estimate how many competitors a keyword has. That number is hallucinated — it changes every run. I wanted the opposite, so I built fiverr-gig-optimizer as a proper Claude Code skill (SKILL.md format, installable as a plugin). The core design rule: every market number — competition counts, demand signal, competitor pricing — comes from a deterministic Python script working on real data. The LLM layer never produces one. If the data isn't there, the skill asks you or says it doesn't have it. The model only writes copy (titles, descriptions) and your own offer choices (delivery times, package contents). How it works technically: query_dataset.py — keyword lookup against the bundled sample dataset, returns a gig_count + match_confidence (HIGH/MEDIUM/LOW). Low confidence → the skill asks you to paste the Fiverr count instead of guessing. score_keyword.py — piecewise-linear competition score over log10(gig_count), anchored so tier labels map intuitively. All constants in a tunable JSON config. analyze_pricing.py — per-tier percentiles (p25/median/p75) of real competitor prices. Too few samples → flagged low-confidence, not fabricated. A vendored Perseus/__NEXT_DATA__ reader for live scraping that uniquely recovers the real "X services available" search total — something no off-the-shelf Apify actor returns. There's also an opt-in community dataset on Hugging Face. Scrape your niche, strip PII, contribute back — the free bundled data gets better over time. Install: /plugin marketplace add Ahad690/fiverr-gig-optimizer /plugin install fiverr-gig-optimizer@fiverr-tools GitHub: https://github.com/Ahad690/fiverr-gig-optimizer Dataset: https://huggingface.co/datasets/Ahad690/fiverr-gigs Would love feedback on the SKILL.md structure and the scoring formula — both are visible and tunable. Happy to answer questions about the Perseus reader approach for gig_count_in_search if anyone's interested. submitted by /u/Nocare420 [link] [comments]

GLM 5.2 and MiniMax M3 are a lot closer/better to Sonnet 4.6 than I expected on coding-agent workloads

We benchmarked GLM 5.2, MiniMax M3, Kimi K2.7-code, Qwen 3.7-Plus and Sonnet 4.6 across nearly 1,000 coding-agent scenarios. The scenarios were run twice. Once normally and once with the relevant skill loaded. The skills came from the Tessl Registry, and the tasks/evals are publicly available in the task-evals-for-skills dataset on Hugging Face for anyone who wants to inspect them. Worth mentioning that I work at Tessl since we're the ones who ran the benchmark. Model Overall Instruction Following Task Completion Skill Lift Cost / Task GLM 5.2 91.9 87.4 97.8 +20.2 $0.289 MiniMax M3 91.4 87.2 97.0 +20.9 $0.207 Sonnet 4.6 90.8 86.1 97.1 +24.4 $0.296 Kimi K2.7-code 88.7 82.5 96.9 +19.5 $0.661 Qwen 3.7-Plus 82.2 77.2 88.9 +19.5 $0.068 The gap at the top ended up being much smaller than I expected. GLM 5.2 finished slightly ahead of Sonnet in overall score while costing slightly less per task. MiniMax M3 landed within half a point of Sonnet and was around 30% cheaper. One thing that probably gets lost in model-vs-model discussions is the effect of context. Every model gained roughly 20 points when the relevant skill was provided. Sonnet actually saw the largest improvement in the group (+24.4). The result I keep coming back to isn't that an open model edged out Sonnet on this benchmark. It's the same skill that improved every model by roughly the same amount. Read full benchmark here: https://tessl.io/blog/open-source-coding-agents-one-ties-sonnet-one-wont-listen/ submitted by /u/rohansrma1 [link] [comments]

Npt

In 1968 five countries that already had nuclear weapons signed a treaty declaring them too dangerous for anyone else to build. India refused, pointing out the treaty did not say nukes were too dangerous to exist, just too dangerous for new entrants. Anthropic built Mythos, deemed it too powerful for public release, then shipped Fable with the same weights but hidden degradation on frontier AI work. The restriction started the day after they finished building. Non proliferation was never about preventing danger. It was about preserving advantage. Mythos 5 goes unrestricted to Microsoft, Nvidia, Google Cloud, AWS, and about 200 other approved partners. Fable 5 goes to everyone else with silent capability limits on frontier ML development. The biggest paying customers get the full product. Potential competitors get a version that quietly gives worse answers on the work that matters most. Anthropic filed confidentially for its IPO one week before this launch. India had a phrase for this kind of arrangement when it refused the NPT. Discriminatory by design. Jensen Huang called the GPU to nuclear bomb comparison stupid. He is wrong about the analogy but right about the instinct behind it. The NPT worked because nuclear weapons require enrichment facilities, centrifuges, and state level infrastructure. AI does not. Qwen has 942 million downloads. DeepSeek V4 ships under MIT license with full weights matching closed frontier models. The knowledge Anthropic is trying to restrict through hidden degradation is already open and available in competing models. You cannot run a non proliferation regime when the material is free to download. Anthropic Fable 5 silently degrades its own performance when it detects someone building a competing model. No warning, no refusal, just worse answers through hidden prompt tweaks and steering vectors Meanwhile DeepSeek published its full R1 training pipeline, failure modes, RL schedules, everything, under MIT license. One lab is hoarding knowledge at the frontier. The other is giving it away. The gap in approach is now wider than the gap in capability, Open is only threatening when you are slow. Alibaba Qwen crossed 942 million downloads on Hugging Face by March 2026. Its share of new open weight derivatives went from 1% in January 2024 to 69% by February 2026. Chinese models now account for 30% of global model usage on aggregator platforms, up from 1% in late 2024. All under Apache 2.0 or MIT licenses, fully permissive. US frontier labs are spending $700 billion on capex while keeping the developmental knowledge locked. China is spending a fraction and giving the knowledge away. Adoption follows access, not origin. Now China too going to do 230 billions+ capex as per report i think... Fable 5 and Mythos 5 are the same model. Mythos goes to 200 approved partners. Fable goes to everyone else, with hidden capability limits on frontier ML work. The stated reason is safety. The result is that US labs build the best tools and then weaken them for the work that advances AI. DeepSeek V4 matches Opus 4.7 on agentic benchmarks and ships under MIT license with full weights. The question is not who builds the better model. It is who gets more people building with it. Some of the Stuff I took from SemiAnalysis, But this will go Nuclear way I don't know submitted by /u/ramanpalkuri9 [link] [comments]

I Built Paper Deck: A Better Way to Discover AI/ML Papers [P]

I do AI research and keep juggling tabs: new ones on arXiv, trending ones on Hugging Face, famous ones somewhere else again. https://preview.redd.it/cg32bshjqd6h1.png?width=1919&format=png&auto=webp&s=00055bb8af699061be0bdcff59f2cb8fa9ab38b6 So I built one site that brings them all together. Pick a paper, read it right there, star the ones you want for later, and it remembers where you stopped reading, even if you switch from laptop to phone. Live: https://ppdeck.com Demo: https://youtu.be/vtyx34JvxX0 It's free and open source - a star on GitHub would mean a lot ⭐ https://github.com/khuynh22/paper-deck submitted by /u/NeitherRun3631 [link] [comments]

Switching from React Native + Node.js (4 YOE) to Agentic AI — need roadmap advice

I have 4 years of experience as a React Native and Node.js developer. I am comfortable with REST APIs, async/await, JSON, MongoDB, authentication, and shipping production apps. I am based in India. What I have learned so far: I recently completed an AI/LLM course that covered: • Pydantic (validation, models, serialization) • LLM theory (transformers, embeddings, attention, tokenization) • OpenAI and Gemini API integration • Prompt engineering (zero-shot, few-shot, CoT, persona prompting) • Prompt formats (ChatML, Alpaca, INST) • Ollama for local LLMs • FastAPI basics • Hugging Face model deployment • Agentic AI fundamentals — built a basic CLI coding agent What I understand conceptually: I understand that an AI agent = LLM brain + tools (Python functions) + agent loop + memory (messages list). I understand RAG, vector databases, the difference between fine-tuning and RAG, and how to structure a backend with Node.js calling a Python AI agent service when needed. What I want to do: I want to transition into Agentic AI / AI Engineer roles in India. I am not looking to become an ML researcher or train models. I want to build production AI agent systems — connecting LLMs to real business data, building tools, RAG pipelines, and shipping real products. My specific questions: 1. Is my current foundation strong enough to start building real agent projects or do I have gaps I am missing? 2. What should my learning roadmap look like for the next 3–6 months given my background? 3. Which frameworks should I prioritise — raw OpenAI API first, then LangChain/LangGraph, or jump straight to frameworks? 4. What kind of projects should I build for a strong portfolio targeting ₹20–35 LPA roles in India? 5. Any specific subreddits, communities, or resources beyond YouTube that helped you in this transition? My planned first 3 projects: • Simple agent with web search + calculator tool (no DB) • Agent connected to MongoDB with RAG • Full FastAPI backend wrapping the agent with a React frontend Any advice from people who have made a similar switch or are hiring in this space would be really helpful. Thanks. submitted by /u/rohitrai0101rm [link] [comments]

I built a tool that maps brain activation responses to creative content, here's what I learned

Started as a thought experiment. When Meta dropped the Tribe v2 model, I saw an opening and spent a few weeks turning it into something real. Neural Lens takes video, audio, image, or text as input and maps network activation patterns over time — showing how your brain responds to creative content, not just whether you clicked or watched. Built it solo. Self-funded. Claude API and Hugging Face under the hood. The use case I kept coming back to: creative teams spend months making content with zero neurological data on how it's actually landing. Clicks and views don't tell you why something works. This does. Try it here: https://huggingface.co/spaces/idkbutitworks/NeuralLens Would love feedback on the concept, the model choice, and where you'd take it. submitted by /u/Dandam_Ra_Doota [link] [comments]

Training-free graph SSL matches GCN with 5× fewer labels — live demo [P]

Hi all, I have been working on this method based on a hunch along with many llm for quite some time. Though first it was being engineered by me but I was learning in supervised ml area but this hunch took to semi-supervised ml and that to too deep. I then became llm orchestrator of sort while 4 llm's tried to figure it out. I put up a live demo on Hugging Face Spaces where you can try it yourself — set the number of labels, click run, see the accuracy. No installation, no code required. Brief about method Optimus — Graph SSL under Extreme Label Scarcity Key Results (PathMNIST, N=2000, 9 classes) Labels Total Optimus GCN 9(1 per class) 73.9 60.6 27(3 per class) 77.3 68.5 45(5 per class) 79.8 77.1 https://huggingface.co/spaces/Keshu007/optimus-graph-ssl Edit : You can can even run the code on your own dataset submitted by /u/Loner_Indian [link] [comments]

On-policy distillation: one of the hottest terms on PapersWithCode [R]

Hi, Niels here from the open-source team at Hugging Face. At paperswithcode.co I am trying to make it easier for people to learn about the newest techniques used across AI papers. One of the hottest terms in AI research that I've recently added is On-policy distillation, also abbreviated as OPD. It's the key post-training behind models like Qwen 3.6 and 3.7, GLM-5.1, and DeepSeek-V4. https://preview.redd.it/yegq2gfag95h1.png?width=3046&format=png&auto=webp&s=f68fdf3ca075f3c4e56051fdd0ebcf97be9bcbc9 On PapersWithCode, you can find the original paper that introduced it, learn more about the method itself, as well as all papers that cite or mention it. Sasha Rush (who used to be a colleague of mine at Hugging Face, now at Cursor) recently made an excellent whiteboard explanation of OPD with Dwarkesh. I've linked this video lecture in the method description on PwC's website, so more people can find it. I'll copy the excellent short description of the method from Dwarkesh here: "The basic idea is this: if the model made a mistake at some point in the rollout (for example, calling a tool that doesn't exist), we want to discourage this specific error, but we don't want to just learn from the final reward, because it's a very noisy signal spread out over the whole trajectory. So we have another model to read this trajectory and figure out where the error was made. It simply inserts some hint tokens into the part of the trajectory immediately above where the mistake occurred. Now, with these injected hint tokens, run a forward pass through the model. You're not having to regenerate a new rollout - aka no new decode required. The hint causes the model to assign lower probabilities to the error tokens. You then train the original model to match these new probabilities, teaching it to downweight that specific mistake." Let me know which other methods I should add! Cheers submitted by /u/NielsRogge [link] [comments]