Hi, I’m Mehdi Fekih
I am a Data Scientist. Data Engineer. Developer. Home Automation Specialist.My Blog
Hermes Agent, LangChain and LangGraph: Choosing the Right Starting Point
Hermes Agent, LangChain and LangGraph are often compared as if they were competing agent frameworks. That comparison misses the main distinction: Hermes is an installable agent runtime, LangChain is a framework for building application-level agents, and LangGraph is a framework for orchestrating stateful workflows.
The practical question is not which one is universally better. It is where you want to start: with an existing agent you configure, with components for a custom agent, or with explicit control over a workflow’s state and transitions.


Three different starting points
| Tool | What you start with | What you design |
| Hermes Agent | An installable agent runtime, CLI and messaging gateway | Configuration, tools, skills, memory and integrations for an existing agent experience |
| LangChain | Higher-level building blocks and an agent loop | A custom application agent using model and tool abstractions |
| LangGraph | State, nodes and transitions for orchestration | A workflow’s control flow, persistence and points for human input |
Hermes Agent: configure an existing runtime
Hermes is intended to be installed and used as an agent. It brings an existing runtime and interfaces, with configuration for model providers, tools, skills, memory and MCP integrations. You shape how the agent works without having to build the whole application shell first.
This is a good fit when the provided agent experience is close to what you need. If your product requires a different user interface or tightly tailored application behaviour, you may need to build around it or choose a development framework instead.
LangChain: build an application agent
LangChain is a higher-level framework for developers building custom applications with language models. Its abstractions help connect models and tools and provide an agent loop, so you can focus on the application’s behaviour and integration points.
Choose this approach when you want to own the application and a higher-level agent abstraction is sufficient. The application’s interface, deployment and product-specific logic remain your responsibility.
LangGraph: model the workflow explicitly
LangGraph is a lower-level orchestration framework and runtime. You represent work as state and connect nodes with transitions. That makes the workflow’s routing and pauses explicit, and supports capabilities such as persistence, durable execution and human review.
LangChain’s agents are built on LangGraph, but the tools serve different levels of abstraction. LangGraph can also be used directly, without adopting LangChain’s higher-level agent framework.
The same request, different ownership
Imagine a request that requires looking up information, deciding whether it is complete, and asking a person to review an uncertain result. With Hermes, you configure an existing agent to work through its available tools and interfaces. With LangChain, you build an application agent and compose its model and tool interactions. With LangGraph, you define the workflow itself: what state is carried forward, which step runs next, and where the process waits for a person.
These approaches can overlap in a real system, but they are not equivalent packages in a feature checklist. The amount of application and orchestration design you take on is different.
Which should you choose?
- Start with Hermes Agent when you want to install and configure an agent that already has a runtime and interfaces.
- Start with LangChain when you are building a custom application and want higher-level components for its agent behaviour.
- Start with LangGraph when state, routing, persistence or human checkpoints need to be explicit parts of the workflow.
A useful first step is to sketch the request, the tools it needs, the information that must persist between steps, and the decisions that require a person. That sketch often makes the appropriate level of abstraction clearer than comparing feature lists.
Further reading
Building a Personal AI Assistant Around Real Workflows
An AI assistant becomes interesting when it fits into the way people work. Answering a question is a start; helping turn an intention into a useful action requires context, the right tools and an understanding of when to stop.
Hermes is a personal AI assistant accessible through Telegram. It can draw on tools and integrations for tasks such as web research, WordPress and server administration. The project provides a concrete setting for a broader question: how do you design an assistant around real workflows rather than a list of features?
Start with the work
A request such as “prepare a summary of this topic” sounds straightforward. In practice, it can involve several steps: clarifying the need, finding sources, separating facts from assumptions and presenting a usable result. A request involving a website or server may instead touch data or trigger changes.
Those tasks do not all call for the same degree of autonomy. Research can produce a proposal for review; an operation that changes content or a system deserves an appropriate check before execution. Start with the desired outcome, then consider the decisions and tools needed to reach it.
A useful assistant is measured less by the number of tools it can call than by the quality of the steps it helps complete.
Telegram as an entry point
Telegram provides a familiar interface for making a request and receiving a response. That simplicity has a useful design implication: a conversation can begin with an intention, without requiring someone to choose a tool or procedure first.
A short exchange does not always contain enough information, though. “Update this article” says neither which content is meant nor what should change or how the result should be approved. A well-scoped assistant needs to be able to ask for those details, present a proposal or say when it lacks the necessary context.
Capabilities with clear boundaries
Connecting an assistant to tools expands what it can do, but every capability brings decisions that need boundaries. Reading a page, preparing a WordPress draft and changing a server have different consequences.
A careful approach is to define for each workflow:
- The objective: what result should the request produce?
- The scope: which information and tools are needed?
- The checkpoint: when should a result be presented or approval requested?
- The limit: what happens if information is missing or an operation fails?
These questions make actions easier to understand and verify. They also help prevent a plausible answer from being mistaken for a completed task: when a tool is involved, its result should be distinguishable from what the assistant proposes or infers.
Memory and context, used selectively
A personal assistant can provide continuity when it can take relevant preferences or information from one exchange into the next. But keeping everything is neither necessary nor desirable. A lasting preference, the temporary context of a search and sensitive information should not all be treated as one category.
The design choice is to retain what actually helps future work, keep context tied to its purpose and allow it to be corrected when it becomes inaccurate. The assistant also needs to account for incomplete or outdated context: it should say so rather than fill the gap with apparent certainty.
One interface, different kinds of work
The value of an assistant like this lies in the transitions between steps. For web research, it can help turn a question into leads and then a summary to verify. For WordPress, the work can move from preparing text to reviewing it before any change. For server administration, the distinction between diagnosis, proposal and action is particularly important.
These examples describe ways to frame work, not a promise that every operation is automated or successful. In each case, the result still needs evaluation: are the sources relevant, does the text reflect the intended message, and does a proposed command fit the system concerned?

What the project brings into focus
Hermes illustrates the appeal of a conversational interface connected to practical tools, as well as its limits. A model can misunderstand a request, miss context or produce a convincing but incorrect answer. Tools can fail or return insufficient information. Access through a messaging app does not remove the need for human review.
The design lesson is incremental: start with understandable tasks, make the steps visible and match autonomy to the consequences. A good workflow leaves room for questions, verification and correction.
I Have a Team of AI Bots. Claude Code Did Their Job in a Few Minutes
AI · AGENTS · LESSONS LEARNED
At home, a small team of AI agents runs around the clock. Hermes, the main bot, receives my requests on Telegram and hands them to specialists: one bot for infrastructure, one for home automation, one for movies, one for health… and Blogscribe, in charge of this blog. On paper, it is the most powerful setup I have ever built: long-term memory, a shared kanban board, dozens of installed skills, automatic routing between models.
One Saturday evening, I asked it for something simple: reformat an article. Not rewrite it, just make it readable. An hour later, I still had nothing. I opened Claude Code on my Mac, pasted the conversation in, and the article was fixed within minutes.
This post tells the story of that evening, because it says something important about AI agents today.
An Hour of Kanban for a Page Layout
Here is what happened, in order:
- Hermes turns my request into a kanban card for Blogscribe, rephrasing it along the way.
- Blogscribe blocks the card: my request is not clear enough. A multiple-choice question.
- New card, new block: changing its own behavior requires approval. Another question.
- I insist: I want a result. Hermes creates a third card, longer than the previous one: diagnose the briefing, prepare an offline preview, a diff, a rollback procedure…
- In the bot’s workspace, there is a generic essay on “the editorial workflow”. Nothing about my article.
Meanwhile, the meters were running: more than two hundred model calls over the day for this one bot, and an estimated ten dollars or so of uncached tokens. Every message I sent to speed things up produced a new card, and therefore a new detour.
And the article itself? The version Blogscribe had produced earlier used Bootstrap components (cards, grids, an accordion) that my theme does not load. As a result, the six steps of the tutorial were folded into an accordion that never opened. An unreadable article.
Claude Code: A Few Minutes, Text Untouched
Claude Code did not open a ticket. It read the article directly in WordPress, spotted the problem, rebuilt the page with native Gutenberg blocks (headings, lists, a quote, a code block), then checked with a script that the visible text was identical word for word before publishing. The old version remained available in WordPress revisions.
Only then did it look into why the bot had failed. The diagnosis comes down to four points:
- No tool. Blogscribe could upload images to the blog, but could neither read nor edit an article. So it fumbled around and invented its own formatting.
- Contradictory instructions. “Draft by default”, “ask for approval”, “write with Codex or stop”: every small touch-up became an approval circuit.
- A polluted context. Its memory was about home automation, résumés and IPTV, but not the blog. And more than a hundred and sixty generic skills were loaded, from p5.js animation to model deployment.
- An overzealous conductor. Hermes rewrote every request into a specification, each time adding requirements I had never expressed.
Same Tools, Same Instruction… and Still a Gap
The easy conclusion would be: “it was a configuration problem”. So Claude Code fixed everything. Blogscribe received a clean tool to read and edit an article, with automatic backup and a refusal of any HTML the theme cannot display. Its instructions were rewritten, its memory cleaned up, its useless skills disabled. Hermes received a simple rule: pass my requests along word for word.
Then I ran a test. I told the bot that, in the article, the section title and the steps were the same size. It used the right tool and it was fast… and it set the steps to the same heading level as the section. Exactly the opposite of what was needed. Faced with the same sentence, Claude Code measured the sizes displayed in the browser (36 px versus 30 px, both bold). It understood that the problem came from the theme and not from the article, then added a rule in WordPress’s additional CSS, without touching the theme’s code.
Tooling explains part of the gap. The rest is the model: understanding what you mean, not just what you write.
What I Take Away
A multi-agent architecture does not make a model smarter. It multiplies intermediaries, and every intermediary rephrases. When the model at the end of the chain misreads a request, the kanban, the skills and the memory only organize the error.
Three rules now seem essential to me:
- One precise tool beats a hundred skills. An agent without the right access improvises, and improvisation is expensive.
- The request must arrive intact. An orchestrator passes things along, it does not embellish.
- The right model in the right place. Hermes remains very good at routing, summarizing and monitoring. But to carry out precise work, it now delegates to Claude Code.
That is the decision made that evening: Blogscribe keeps the conversation and hands every article touch-up to Claude Code. The bot stays the switchboard; Claude does the work.
Two Memories, One Source of Truth: Designing a Reliable Memory Layer for AI Agents
The memory failures that hurt most in long-running agents come from bookkeeping. Nobody can say where a stored fact came from, whether it is still true, or which of two contradicting entries should win. Retrieval quality matters, but a perfect retriever over an unreliable store returns unreliable answers faster.
This article describes an architecture that keeps two memories and gives them different jobs. A human-readable Markdown knowledge base, organized like an Obsidian vault, holds durable truth. A semantic conversational memory, backed by embeddings, holds a searchable projection of that truth plus recent context. The first is canonical. The second can be deleted and rebuilt at any time.
Why one memory is never enough
A pure vector memory is convenient. The agent says something, the system embeds it, and a later similarity search brings it back. It also has no concept of a fact being replaced. Suppose a deployment preference changes in March. The January note and the March note can both sit close to the query “how do we deploy”, and the one that surfaces may depend on phrasing and chunk boundaries rather than on which is current.
A pure file-based knowledge base has the opposite profile. It is accurate, diffable and reviewable by a person, yet an agent can miss the right note when the user phrases a question in words the note never used. Each store covers the other’s weakness, provided the relationship between them is strict.
If the index and the notes disagree, the index is wrong by definition.
Two stores, two jobs
Canonical knowledge base
- Markdown files with structured frontmatter.
- Owns decisions, preferences, procedures and facts, each with a source and status.
- Written through a validated path, by people or agents.
- Versioned and backed up because losing it is real loss.
- Read by people first, agents second.
Semantic memory
- Embedded chunks of canonical notes plus recent conversation turns.
- Owns nothing durable.
- Written only by the indexer.
- Disposable: losing it costs retrieval speed until a rebuild.
- Every hit points back to a canonical note.
The mental model is a ledger and a search engine. The ledger is careful about what it accepts. The search engine is fast, approximate and disposable. Nobody audits a search engine; they audit the ledger.
Anything an agent retrieves must carry the ID of a canonical note, or be labelled as unverified conversational context. An answer built from the second kind should say so.

What a canonical note carries
Each note is a Markdown file with frontmatter and a short body. The fields that matter are a stable ID, a type such as decision or procedure, a status such as active or superseded, provenance, sensitivity, and the replacement chain.
- Provenance: who or what produced the claim, with a pointer to the evidence.
- Status: whether the note is active, disputed, draft or superseded.
- Sensitivity: metadata that can travel into retrieval filters.
- History: what the note replaces and when it changed.
The body stays plain prose, because people read it. A note a person cannot read is a note nobody will correct.
The write path
New knowledge never goes straight into the vault. It enters as a candidate and passes through a fixed sequence:
- Capture. Propose a candidate with the raw excerpt it is based on.
- Classify. Decide what it is and whether it belongs in durable memory at all.
- Filter. Redact or reject credentials, tokens and personal identifiers before persistence.
- Validate. Check schema, provenance, duplicates and conflicts.
- Commit. Write the canonical note in one reviewable operation.
- Index. Chunk, embed and upsert vectors with the note ID and content hash.
The order is deliberate. Filtering sits before validation and commit because a secret that reaches any durable store has already leaked, and embeddings are a poor place to discover that.
Provenance prevents quiet authority
A claim without a source stays in draft and is never served as fact. The source field distinguishes what a person stated, what a document says, and what the agent inferred.
This prevents a quiet failure: an agent infers a preference from one remark, stores it, and three sessions later repeats it as established. When the source is visible as an agent inference, the claim cannot be promoted without confirmation.
Validation and conflict handling
On commit, compare a candidate with active notes of the same type and subject. There are three outcomes:
- Duplicate. Merge into the existing note and update its review date.
- Extension. Create a new note that links to the old one.
- Contradiction. Do not overwrite anything. Send the candidate to review.
When a replacement is confirmed, the new note records supersedes. The old note stays on disk, changes to superseded and is excluded from the index by default. Last-write-wins destroys context; keeping both lets retrieval choose by phrasing.
Rule of thumb. An agent may add knowledge on its own authority. Replacing knowledge requires a source that outranks the original.
Privacy filtering and re-indexing
The canonical store is plain text. If sensitive content slips in, it can be found with a text search, removed, and re-indexed by note ID. Doing the same inside a vector store alone is much harder because there is no readable source to search.
Because the index is derived, rebuilding it is routine. Triggers include an embedding model change, new chunking rules, a schema change or an edit to a note. Build a full rebuild into a new index and swap it in when complete, so the agent never queries a half-built one. Keep a few regression questions with known answers to check retrieval after the swap.
Limits worth stating
The review queue can grow faster than anyone clears it. Conflict detection can miss contradictions phrased very differently. Model-based classification makes mistakes. Sampling and periodic review therefore belong in the operating routine, and the canonical store must stay readable by people.
Conclusion
Durable knowledge lives in files a person can read and correct. Semantic memory is an index over those files and holds no truth of its own. Every write records provenance, resolves conflicts explicitly and filters sensitive data before anything persists.
Agents with this structure can still be wrong, but their errors are traceable to a note, a source and a decision. That makes them fixable.
How to Back Up Your Personalized AI Agent to GitHub
The more you use an AI agent, the more valuable it becomes. You customize its personality, add skills, teach it how you work, and build up memory and context. If the machine running it fails, rebuilding all of that from scratch would be painful.
A practical safety net is to back up the files that make your agent personal into a private GitHub repository — while carefully keeping secrets, tokens, and credentials out of it.
⚡ The golden rule: back up the agent’s identity, not the keys to your accounts. A private repo is a backup location, not a password vault.
🗂️ What to back up
The goal is simple: (your personalized agent) − (generic install) − (secrets). Concretely, that usually means:
- ⚙️ Configuration files — Model, provider, personality, terminal preferences, and other agent-level settings.
- 👤 Personality / instructions — The role, tone, and rules that define how your agent behaves and responds.
- 🧠 Memory files — Long-term context and preferences — review carefully for personal info first.
- ⏰ Scheduled tasks — Cron jobs and recurring automations that are easy to forget during a rebuild.
- ✨ Custom skills — Scripts and workflows you created or modified for your specific needs.
- 🚫 Never include — Secrets, tokens, credentials — these must never go into the repo.
🚫 What never belongs in the repo
.envfiles- API keys and access tokens
- OAuth and authentication files
- Private URLs, chat IDs, or other sensitive identifiers
🚀 The backup workflow
1. Create a private GitHub repository
Create a new repo dedicated to the backup and set visibility to Private. Initialize it empty — no README, no .gitignore, no license — so the agent can set it up cleanly.
2. Generate a fine-grained access token
In GitHub, go to Settings → Developer settings → Personal access tokens → Fine-grained tokens. Restrict it to the backup repository only, with Contents: Read and write permission. Set an expiration date if you can — a leaked token with an expiry does far less damage.
3. Store the token securely
Copy the token into a password manager. Never paste it into files that will be committed. If it is ever exposed, revoke it in GitHub immediately and generate a replacement.
4. Connect the agent
Add the token through your agent’s configuration so it is stored as a secret, not inside the files you plan to back up. For example:
agent config set GITHUB_TOKEN <your-token>
5. Run the first backup manually
Ask the agent to commit the configuration, memory, skills, and scheduling files. Then open the repo and review every committed file — confirm that no keys, tokens, or private notes slipped in.
6. Automate recurring backups
Once the first backup is clean, schedule a daily job and a notification after each run. Keep reviewing occasionally: automation is helpful, but it should not be blind.
💭 Final thoughts
A personalized AI agent becomes hard to replace once it holds your settings, memory, and workflows. A clean private GitHub backup gives you a restore path when hardware fails or you migrate machines — without turning GitHub into a secrets manager.
Inspired by a guide from Zawanah about backing up a Hermes agent to GitHub.
Awesome Public Datasets: A Treasure Map for Data-Driven Projects
If you have ever started a machine learning project, built a dashboard, written a research paper, or simply wanted to explore real-world data, you already know the hardest part is often not the code. It is finding a good dataset.
That is why the GitHub repository Awesome Public Datasets is such a valuable resource. It is a curated collection of public datasets organized by topic, making it easier for developers, researchers, analysts, students, and data enthusiasts to discover high-quality data sources without spending hours searching across the web.
Whether you are looking for climate records, economic indicators, social network graphs, image datasets, government data, healthcare resources, or machine learning benchmarks, this repository acts like a map to the public data ecosystem.
What Is Awesome Public Datasets?
Awesome Public Datasets is an “awesome list” dedicated to topic-centric public data sources. Like other awesome lists on GitHub, its goal is simple: collect useful links in one place and organize them so people can find what they need quickly.
The repository includes datasets from a wide range of domains, including agriculture, biology, chemistry, climate and weather, cybersecurity, economics, education, energy, finance, GIS and geospatial data, government, healthcare, image processing, machine learning, natural language processing, neuroscience, physics, social sciences, software, sports, time series, and transportation.
It also includes complementary collections, which can lead users to even more dataset repositories and archives. In short, it is not a single dataset. It is a gateway to hundreds of datasets.
Why This Repository Is So Useful
The internet is full of data, but not all data is easy to find, clean, documented, or usable. Many valuable datasets are buried inside university pages, government portals, academic archives, old project websites, or research labs.
Awesome Public Datasets helps solve that discovery problem. Instead of searching Google for “free public dataset for network analysis” or “open agriculture data,” you can browse a categorized list and quickly find relevant sources.
For example, the repository points to well-known resources such as the Stanford Large Network Dataset Collection for graph and network research, Open Food Facts for food product data, NBER Patent Citations for economics and innovation research, DIMACS Road Networks Collection for transportation and graph algorithms, and many climate, biology, finance, and machine learning datasets.
Each listing usually includes a short description and a link to the original data source. Many entries also include metadata links from the repository’s companion project, apd-core.
A Dataset Directory for Many Audiences

For Data Scientists
Data scientists can use it to find datasets for exploratory analysis, predictive modeling, visualization, and portfolio projects. Instead of working with the same few beginner datasets repeatedly, they can explore more specialized real-world data.
For Machine Learning Engineers
Machine learning engineers can find benchmarks and domain-specific data for experimenting with models. Categories like image processing, natural language, time series, and cybersecurity are especially useful for ML workflows.
For Researchers
Researchers can discover public data sources related to biology, physics, neuroscience, social sciences, climate, economics, and more. The repository can serve as a starting point for literature reviews, reproducible experiments, or interdisciplinary research.
For Students
Students learning Python, R, SQL, data visualization, or statistics can use the repo to find project ideas. Real datasets make learning more meaningful because they contain imperfections, surprises, and domain context.
For Journalists and Analysts
Data journalists and analysts can use the collection to locate public-interest datasets, especially in government, economics, transportation, education, healthcare, and climate.
What Makes It Better Than a Random List of Links?
The strength of Awesome Public Datasets is not just that it contains many links. It is the organization and curation.
The datasets are grouped by domain, so browsing feels natural. If you are interested in geospatial analysis, you can jump to GIS. If you are researching transportation networks, you can explore Transportation or Complex Networks. If you are looking for NLP resources, there is a Natural Language section.
The repository also uses status icons for entries. Some links are marked as healthy, while others are marked as needing attention. That is important because public dataset links often break over time. Seeing that maintenance status gives users a quick signal about whether a resource may need verification.
Another important detail: the README notes that the repository is automatically generated by apd-core. Contributors are asked not to edit the generated README directly, but to contribute through the appropriate metadata workflow. That makes the project more structured than a hand-edited list.
Great Project Ideas Using Awesome Public Datasets
- Build a climate dashboard: Use climate and weather datasets to visualize temperature changes, rainfall patterns, or extreme weather events over time.
- Analyze transportation networks: Explore road network datasets or public transport data to study shortest paths, congestion, or urban accessibility.
- Create a food product explorer: Use Open Food Facts or other agriculture and food datasets to analyze nutrition, ingredients, product origins, or labeling trends.
- Study social networks: Use graph datasets from the social networks or complex networks sections to learn network analysis, centrality, community detection, and graph visualization.
- Practice time series forecasting: Find time series datasets related to energy, finance, climate, or transportation and build forecasting models.
- Train an image classification model: Browse image processing datasets and experiment with computer vision techniques.
- Investigate public policy questions: Government, education, economics, healthcare, and social science datasets can support projects around inequality, public spending, population trends, or policy outcomes.
If you want help turning one of these datasets into a production-ready pipeline — ETL, storage, or a deployed model — check out my data engineering services or get in touch.
A Few Things to Keep in Mind

Awesome Public Datasets is a directory, not a guarantee that every dataset is ready to use immediately.
Before starting a project, you should always check the dataset license, whether the data is free or requires payment, update frequency, file format, documentation quality, privacy or ethical considerations, whether the link is still active, and whether the dataset is suitable for commercial use.
The repository itself notes that most datasets are free, but some are not. That distinction matters, especially for production or commercial projects.
Also, because many datasets come from third-party sources, quality can vary. Some may be clean and well-documented, while others may require significant preprocessing.
Why Public Datasets Matter
Public datasets are one of the foundations of modern data work. They make research more transparent, help students learn by doing, allow developers to test ideas, and enable journalists and citizens to investigate important questions.
Open data also lowers the barrier to innovation. A student with a laptop can analyze climate trends. A developer can build a prototype with public transportation data. A researcher can compare results using shared benchmarks. A startup can validate an idea before collecting proprietary data.
Repositories like Awesome Public Datasets make that ecosystem easier to navigate.
Final Thoughts
Awesome Public Datasets is one of those GitHub repositories worth bookmarking immediately. It saves time, sparks ideas, and opens doors to data from dozens of fields.
If you are learning data science, building machine learning models, writing research, creating visualizations, or looking for your next portfolio project, this repository is an excellent place to start.
The next time you ask, “Where can I find a good dataset?”, start with Awesome Public Datasets. And if you need a hand turning that data into something real — a dashboard, a model, a pipeline — I do this for a living. Let’s talk.
What I Can Do For You
Data Science
Unlocking insights and driving business growth through data analysis and visualization as a freelance data scientist.
Data Analysis
Helping businesses make informed decisions through insightful data analysis as a freelance data analyst.
Website Development
Bringing your online presence to life with customized website development solutions as a freelance developer.
Home Automation
Transforming your living space into a smart home with custom home automation solutions as a freelance home automation expert.
Docker & Server
Optimizing your software development and deployment with Docker and server management as a freelance expert
Consultancy
Identification of scope, assessment of feasibility, cleaning and preparation of data, selection of tools and algorithms.
My Portfolio
My Resume
Education
Msc Data Science And Artificial Intelligence
2022 - 2023Training in data science & artificial intelligence methods, emphasizing mathematical and computer science perspectives.
Master In Management
EDHEC Business School (2005 - 2009)English Track Program - Major in Entrepreneurship.
BSc in Applied Mathematics and Social Sciences
University Paris 7 Denis Diderot (2006)General university studies with a focus on applied mathematics and social sciences.
Education
Higher School Preparatory Classes
Lycée Jacques Decour - Paris (2002 - 2004)Classe préparatoire aux Grandes Écoles de Commerce. Science path.
Scientific Baccalaureate
1999 - 2002Mathematics Major
Data Science
Python
SQL
Machine learning libraries
Data visualization tools
DESIGBig Data (Spark, Hive)
Data Analysis
Spreadsheet software
Data visualization tools (Tableau, PowerBI, and Matplotlib)
Statistical software (SAS, SPSS)
SAP Business Objects
Database management systems (SQL, MySQL)
Development
HTML
CSS
JAVASCRIPT
SOFTWARE
Version Control Systems
MLOps
CI/CD
Docker and Kubernetes
AutoML
Model serving frameworks
Prometheus, Grafana
Job Experience
Data Engineer / Data Scientist - Managing Director (Alphaprime)
(2024 - Present)NLP tools (chatbots, LLM, LangChain), Fine-tuning and prompt engineering, Data wrangling (Alteryx) and data visualization (Tableau, Power BI), Dynamic dashboards with Streamlit, Gradio, Dash, Computer vision (anomaly detection, video stream analysis), MLOps deployments (Docker, Google Cloud, Azure, AWS)
Data Engineer (Ofi Invest Asset Management)
(Dec 2023 - Apr 2024)Data transformation with Cloud Dataprep (Trifacta & Alteryx), 70% reduction in ETL pipeline run time by optimizing Airflow DAGs, Data warehouse on Google Cloud Platform, Data acceptance and regression testing with BigQuery, Quality monitoring with Tableau and Colab notebooks
Consulting, Automation and Security
(2019 - 2021)Implementation of automated reporting tools via SAP Business Objects, Processing and securing sensitive data (data wrangling, encryption, redundancy), Remote monitoring management solutions via connected objects (IoT) and image processing, Internal pentesting and network security consulting, VPN implementation, Outsourcing of servers
Consulting, E-commerce and Digital Marketing
(2017 - 2019)Consulting in e-commerce and digital marketing (Bangkok area), Booking.com, Airbnb, Agoda online booking management for third parties, SEO in the hotel industry.
Consulting, internal company network
(2016 - 2017)Implementation of corporate networks and virtualization solutions (rack cabling, firewalls, proxmox virtualization), Management of firewalls and internal networks. (pfSense)
Entrepreneurship Experience
Founder, web developer
(2009 - 2017)Programming and maintenance of websites and web applications, Consulting in digitalization and process optimization for local SMEs, Implementation of turnkey e-commerce solutions.
High-end property management (JM Gestion)
(2013 - 2016)Rental management of a property portfolio for short-term tourist rentals in Paris and supervision of renovation works, Apartment sourcing for foreign buyers, high-end real estate investment advice (>€1M)
Corporate Banking
Assistant Fund Manager
Credit Portfolio Management - CALYON - 2008 - 2009● Preparation of committee notes for new ABS/CDO credit derivative investments ● Calculation and measurement of portfolio risk (Value-at-Risk, exotic and vanilla ABS, SWAP, liquidity lines) ● Daily monitoring of credit derivatives portfolio structures (Mark-to-Market, P&L, re-financing) ● Design of risk measurement and decision support tools in VBA.
Credit Risk Analyst
Risk and Controls Department – NATIXIS – Paris – 2008Study of financing files for review by the credit committee (structured finance, commodity trade finance, and car manufacturers) ● Financial analysis, rating, and credit risk analysis of a portfolio of companies ● Financing files studied: from €1m to €1000m
Retail Banking
Assistant Business Account Manager
BNP Paribas - 2006● Writing reports on business plans for small SMEs ● Risk and feasibility Analysis and Decision making ● Negotiation of financing xpackages with applicants
Pierre Toul
Chief Technical OfficerData & Process Automation
Jan. 2025 – Sep. 2025Mehdi a su rapidement comprendre nos processus métiers et transformer des outils Excel/VBA existants en solutions Python plus robustes et maintenables. Son autonomie, sa rigueur et son attention portée aux utilisateurs ont facilité l'intégration et l'adoption des nouveaux outils.
Arkadus Romitry
Engineering Data LeadData Engineering & Analytics
Sep. 2024 – Jan. 2025Mehdi a mené une analyse complexe sur plusieurs années de données techniques et a su en extraire des tendances utiles aux équipes métier. Il combine efficacement maîtrise technique, rigueur analytique et capacité à restituer des résultats complexes de manière claire.
Contact Me
Mehdi Fekih
Data Scientist.I am available for freelance work. Connect with me via this contact form or feel free to send me an email.
Phone: +33 (0) 7 82 90 60 71 Email: [email protected]