Faycal Amrouche

• Agentic memory runtime (Project GMem): built a Neo4j-backed memory layer that sanity-checks writes as they come in, so long-running agents don't drift off, mix up memories, or start making things up (LangChain/AutoGen).
• Model Context Protocol (MCP) stuff: wired up standard MCP servers so agents can call tools, pull in context, and talk to each other without duct tape.
• Bitemporal audit logs: dual-timeline logging so you can replay what the agent did, roll things back, and actually see what's going on at runtime.
• Schema & rule induction: pipelines that mix LLMs with old-school validation to turn messy text into clean schemas, graphs, and runnable rules.

• Field telemetry ingestion: put together ingestion microservices (Django, PostgreSQL, Apache Kafka) that chew through live sensor streams from the gas plant.
• Speeding up reporting: cleaned up the reporting pipelines and took admin/compliance reporting from 15 days down to under an hour.
• Telemetry chat assistant: hacked together a LangChain agent so site engineers can just ask questions in plain English over live Kafka streams and get quick diagnostics back.
• Noise filters: added simple statistical checks to catch bad sensor readings, spikes, and junk before they hit the database.

• Enterprise RAG pipelines: built end-to-end RAG setups (LangChain, LlamaIndex) that can dig through big messy piles of legal, technical, and engineering docs.
• Smarter querying: broke complex questions into smaller parallel lookups across vector indexes and Neo4j graphs, with function calling holding it together.
• Arabic + English search: tuned hybrid vector/keyword search across both languages — faster retrieval, better hits, async indexing under the hood.
• Backend glue: shipped fast Python/FastAPI endpoints hooking the RAG pipelines up to company databases and login/security stuff.

• Signal processing: messed with digital filters (Fourier, Butterworth, Wavelet) and cross-validation for jumpy, non-stationary environmental data.
• Forecasting & risk: put together time-series regression and classification models for key environmental variables, keeping things properly separated so forecasts stay honest.

LangChain · LlamaIndex · AutoGen · CrewAI · LangGraph · Model Context Protocol (MCP) · ReAct planning agents · multi-agent orchestration loops · self-healing workflows · tool & function calling · LLM guardrails & trajectory logging

Knowledge graphs (Neo4j/Cypher) · constraint satisfaction problems (CSP) · rule induction · pattern mining · automated reasoning · symbolic schema validation · cognitive distillation · program induction

Agentic RAG · Graph RAG · vector databases (ChromaDB, Pinecone, Qdrant, FAISS) · hybrid search (dense + sparse/BM25) · transactional active-memory runtimes · bitemporal audit ledgers · context compression & chunking

SCADA stream ingestion · time-series analytics · digital signal processing (Fourier, Butterworth, Wavelet) · predictive maintenance · remaining useful life (RUL) estimation · real-time anomaly detection

Python · C++ · Java · FastAPI · Django · Apache Kafka · PostgreSQL · Redis · Docker · asynchronous microservices · RESTful/gRPC APIs · Linux · AWQ quantization · local air-gapped LLM execution (Ollama, vLLM) · reinforcement learning

AI-assisted workflows (Cursor, Claude Code, Gemini CLI) · GitHub Actions · PyTorch · Hugging Face Transformers · Scikit-Learn · NetworkX · system profiling pipelines

LLM agents are great at reasoning, planning, using tools, and clicking around — but they're pretty bad at actually learning from experience. Most of them just save everything as one giant chat log and re-read the whole thing next time, which gets slow, expensive, and brittle fast.

My PhD idea is cognitive distillation: instead of hoarding every detail, agents boil repeated experiences down into small reusable playbooks — schemas — they can just run next time. The work is about how agents form those schemas, keep them fresh, and forget the ones that stop being useful. Full write-up on the blog.

• The issue in a nutshell: re-reading everything is slow, tiny changes throw agents off, and memory fills up with junk.
• The fix I'm going for: turn raw experience into compact, tested, runnable knowledge — and prune it like a garden, not a hard drive.

• Grad thesis: grounded memory for agents that holds up under noisy, long-horizon stress tests (17.88/20) — basically making sure agent memory doesn't fall apart when things get messy.
• Fun fact: ranked 1st in Tipasa on the national Bac exam (18.84/20).
• What I studied: distributed systems, agentic workflows, databases, NLP, reasoning, knowledge representation, constraint programming & optimization, hybrid AI, security, graph theory, stats.

• Real-time fraud detector (1st place): mixed Neo4j graph features with Isolation Forest to flag weird money flows — built in 48 hours.
• Risk & forecasting engine (1st place): time-series modeling + stochastic optimization for sizing up operational risk.
• Graph optimizer (1st place): graph analytics + constraint programming for assigning resources fast under tight deadlines.

Tech lead & IT manager at GDG/GDSC ENSIA — ran hackathons and tech meetups, plus hands-on workshops on Docker, backends, and building agents with LangChain/LlamaIndex.

• English — Fluent (IELTS 8.0/9.0)
• French — Fluent (TCF C1)
• Arabic — Native (formal register)