Show HN: An MCP server that gives LLMs temporal awareness and time calculation

Fair point on the metaphor—let me be concrete.

What’s new here isn’t just exposing `current_datetime()`. The server also gives the model tools to reason about time:

  (1) time_difference(t1, t2)  – exact gaps with human wording  

  (2) timestamp_context(t)      – “weekend evening”, “workday morning”  

  (3) time_since(t)             – “2 h ago, earlier today”  

Ask Claude “what patterns do you see so far?” after a few exchanges.

If you still find it trivial after trying, happy to hear why—genuinely looking for ways to push this further. Thanks for the candid feedback.

Finding a good title is really hard. I'd appreciate any advice on that. You'll notice I wrote the article several weeks ago, and that's how long it took me to figure out how to pitch on HN. I'd appreciate any feedback to improve. Thanks!

Clearly an honest mistake but yeah a metaphor probably shouldn't be used in a title like this, since many readers will take it literally. I've changed the title now to language from the article.

(Submitted title was "Show HN: I gave Claude a sundial and it built a calendar")

That's MCP/AI libraries for ya.

Give it a picture of the Sun at the same time every day, and lets see if it comes up with a calendar from that.

Agreed. I’m tired of these ridiculous claims by people just trying to hype up LLMs. Flagging this article.

Hey, thanks so much for sharing, your repo is really cool, including the GEMINI.md context engineering file!

I am curious: You say "offline-first or local-first, quantified self projects", what models do you use with your projects?

I find the LLMs like the Claude and GPT families to be incredibly impressive for integration and metacognition — however, I am not sure yet what LMs are best for that purpose, if there are any.

Your "Augmented Awareness" framework seems to be metacognition-on-demand. In practice, how has it helped you recently? Is it mostly automated, or does it require a lot of manual data transfers?

I am assuming that the MCP server is plugged into a model, and that in the model you run prompts to run retrospectives.

Have you written about this?

One‑shot timestamps (the kind hard‑coded into Claude’s system prompt or passed once at chat‑start) go stale fast. In a project I did with GPT‑4 and Claude during a two‑week programming contest, our chat gaps ranged from 10 seconds to 3 days. As the deadline loomed I needed the model to shift from “perfect” suggestions to “good‑enough, ship it” advice, but it had no idea how much real time had passed.

With an MCP server the model can call now(), diff it against earlier turns, and notice: "you were away 3 h, shall I recap?" or "deadline is 18 h out, let’s prioritise". That continuous sense of elapsed time simply isn’t possible with a static timestamp stuffed into the initial prompt; you'd have to create a new chat to update the time, and every fresh query would require re‑injecting the entire conversation history. MCP gives the model a live clock instead of a snapshot.

The current time (and location of the user, looking at you google gemini) is injected in most LLM chats now isn't it?

You can program just for fun, without having to make it a professional project. Just like you can do some woodworking without having the goal of becoming a professional carpenter.

This really isn't dissimilar to any work I've seen in a professional setting, minus the screenshot docs. I agree those are bad. Everything useful is in the README.

`uv` is great but `pipenv` is a perfectly well-tested Python dependency manager (albeit slow). Down in the instructions it explicitly asks you to use `pipenv` to manage* dependencies. I also do not think your assertion of "what is a Pipfile in any context" is fair, as I don't think I've ever seen a project list a dependency manager and then explicitly call out artifacts that the dependency manager may require to function.

That's exactly what I've been thinking too!

MCP + LLMs = our solution to data integration problems, which include context awareness limitations.

It's an exciting development and I am glad you see it too!

I'm sorry for the misleading title about a sundial, it was a metaphor, and based on the feedback here, if I had to do it again I would pick a different one. :-)

My only worry with these MCP "sensors" is that they add-up to the token cost — and more importantly to the context window cost. It would be great to have the models regularly poll as new data and factor that into their inferences. But I think the models (at least with current attention) will always have a trade-off between how much they are provided and what they can focus on. I am afraid that if I provide Claude numerous senses, that it will lower its attention to our conversation.

But your exciting comment (and again I apologize for disappointing you!) makes me think about creating an MCP server that provides like the position of the sun in the sky for the current location, or maybe some vectorized representation of a specific sundial.

I think the digitized information that we experience is more native to models (i.e., require fewer processing steps to extract insights from), but it's possible that providing them this kind of input would result in unexpected insights. They may notice patterns, i.e., more grumpy when the sun is in this phase, etc.

Thanks for your thoughtfulness!

Glad the little political wink landed with at least one reader!

You’re right: Stripping away all ambient context is both a bug and a feature. It lets us rebuild “senses” one at a time—clean interfaces instead of the tangled wiring in our own heads.

Pauses are the first step, but I’m eager to experiment with other low‑bandwidth signals:

• where the user is (desk vs. train) • weather/mood cues (“rainy Sunday coding”) • typing vs. speech (and maybe sentiment from voice) • upcoming calendar deadlines

If you could give an LLM just one extra sense, what would you pick—and why?

Great question! Injecting a raw epoch each turn can work for tiny chats, but a tool call solves four practical problems:

1. *Hands‑free integration*: ChatGPT, Claude, etc. don’t let you auto‑append text, so you have to manually do it. Here, a server call happens behind the scenes—no copy‑paste or browser hacks.

2. *Math & reliability*: LLMs core models are provably not able to do math (without external tools), this is a theoretical limitation that will not change. The server not only returns now() but also time_difference(), time_since(), etc., so the model gets ready‑made numbers instead of trying to subtract 1710692400‑1710688800 itself.

3. *Extensibility*: Time is just one "sense." The same MCP pattern can stream location, weather, typing‑vs‑dictation mode, even heart‑rate. Each stays a compact function call instead of raw blobs stuffed into the prompt.

So the tool isn’t about fancy code—it’s about giving the model a live, scalable, low‑friction sensor instead of a manual sticky note.

It's good idea. I didn't think of it because this project came about a "let's try to write a remote MCP server now that the standard has stabilized."

But there are some issues:

1. Cheaper + Deterministic: It is much more costly, both in terms of tokens and context window. (Generating the code takes many more tokens than making a tool call.) And there can be variability in the query, like issues with timezones.

2. Portability: It is not portable, not all LLM or LM environments have access to a code interpreter. This is a much lower resource requirement.

3. Extensibility: This approach is extensible, and it allows us to expand the toolkit with additional cognitive scaffolds that help contextualize how we experience time for the model. (This is a fancy way of saying: The code only gives the timestamp, but building an MCP allows us to contextualize this information — "this is time I'm sleeping, this is the time I'm eating or commuting, etc.")

4. Security: Ops teams are happier approving a read-only REST call than arbitrary code running.

One last thing I will say: The MCP server specification is unclear how much the initial "instructions", the README.md of the server for the model, is discovered. In the "passage-of-time" MCP server, the instructions provide the model with information on each available tool as well as the requirement to poll the time at each message.

In practice, this hasn't really worked. I've had to add a custom instruction to "call current_datetime" at each message to get Claude to do it consistently over time.

Still, it is meaningful that I ask the model to make a single quick query rather than generate code.

Because LLMs are notoriously unreliable especially over long context. Telling it something like "check the time before every turn" is going to fail after enough interactions. MCP call is more reliable for programmatic and specific queries, like retrieving the time.

Without engaging in the whole "anthropomorphizing" debate in this post, I'll say I reject the framing, for many reasons I'd be happy to discuss.

At the same time I understand what you mean and I agree that no, this does not give any LLM any sense of anything, in the same way that we conceive it. But it provides them context with take for granted in service of further customizing their outputs.

Your "calendar" is nice, thanks for sharing. :)

It's even a blocker for some design patterns. Ie it's difficult to discuss options and choose the best one when the AI agrees with you no matter what. If you ask "But what about X" it is more likely to reverse course and agree with your new position entirely.

It's really frustrating. I've come to loathe the agreeable tone because every time i see it i remember the times where i've hit this pain point in design.

In my ChatGPT customization prompt I have:

    Not chatty.  Unbiased.  Avoid use of emoji.  Rather than "Let me know if..." style continuations, list a set of prompts to explore further topics.  Do not start out with short sentences or smalltalk that does not meaningfully advance the response.

As an aside, I like the further prompt exploration approach.

An example of this from the other day - https://chatgpt.com/share/68767972-91a8-8011-b4b3-72d6545cc5... and https://chatgpt.com/share/6877cbe9-907c-8011-91c2-baa7d06ab4...

One part of this in comparison with the linked in post is that I try to avoid delegating choices or judgement to it in the first place. It is an information source and reference librarian (that needs to be double checked - I like that it links its sources now).

However, that's a me thing - something that I do (or avoid doing) with how I interact with an LLM. As noted with the stories of people following the advice of an LLM, it isn't something that is universal.

I'm struck by how often Claude responds with "You're right! Now let me look at the file..." when it can't know whether I'm right until after it looks at the file in question.

First, I think various models have various degrees of sycophancy — and that there are a lot of stereotypes out there. Often, the sycophancy, is a "shit sandwich" — in my experience, the models I interact with do push back, even when polite.

But for the broader question: I see sycophancy as a double‑edged sword.

• On one side, the Dunning–Kruger effect shows that unwarranted praise can reinforce over‑confidence and bad decisions.

• On the other, chronic imposter syndrome is real—many people underrate their own work and stall out. A bit of positive affect from an LLM can nudge them past that block.

So the issue isn't "praise = bad" but dose and context.

Ideally the model would:

1. mirror the user's confidence level (low → encourage, high → challenge), and

2. surface arguments for and against rather than blanket approval.

That's why I prefer treating politeness/enthusiasm as a tunable parameter—just like temperature or verbosity—rather than something to abolish.

In general, these all-or-nothing, catastrophizing narratives in AI (like in most places) often hide very interesting questions.

What am I missing? I am not seeing this particular example as sycophantic. Claude is saying, something like user's assertion is improbable but if it was the case, user needs to show/ prove some of the things in this table.

They have introduced a beta 'Preferences' feature recently under Custom Instructions. I've had good results from this preference setting in GPT:

    Answer concisely when appropriate, more 
    extensively when necessary.  Avoid rhetorical 
    flourishes, bonhomie, and (above all) cliches.  
    Take a forward-thinking view. OK to be mildly 
    positive and encouraging but NEVER sycophantic 
    or cloying.  Above all, NEVER use the phrase 
    "You're absolutely right."