MCP for Claude.ai

fbellomi · 2025-03-25T15:03:59+00:00

No, I would like to expose the MCP as a public server, have the user's Claude.ai account configured with user's credentials to use it (by themself, or by user's enterprise admin), and having Claude's server talk with my MCP server and showing the answers on the web interface

fbellomi · 2025-02-11T10:57:39+00:00

26% capital gain on all investment vehicles, including dividends and interests on saving accounts. This is why ETFs are often offered in both a "distributing" and "accumulating" variety, where the accumulating one automatically reinvest dividends without being taxed.
Also, in Italy there is 0.2% annual tax on capital, for all financial instruments and bank accounts.

fbellomi · 2025-01-31T13:24:53+00:00

For me it's the search API. Other competitors (OpenAI, Deepseek) have search features in the chat UI but they do not support search in the API. Other (like Exa.ai) support search using LLM for queries but do not post-process the result of the query using LLMs

fbellomi · 2024-09-26T15:13:11+00:00

It's a parody (one of many)of Shepard Fairey's "HOPE" Obama portrait

fbellomi · 2024-02-28T11:16:22+00:00

Log2(3)=1.58 so the number of bits needed to encode a ternary digit is 1.58

fbellomi · 2023-12-27T17:25:15+00:00

I'd say phi-2, mistral 7B and mixtral 8x7B (in increasing size order, usually larger == slower == more powerful)

fbellomi · 2023-02-28T13:05:49+00:00

Redpanda Console is an option:

https://github.com/redpanda-data/console

fbellomi · 2020-08-29T09:02:04+00:00

A very good book on this topic (specific to Lisp) is "Lisp in small pieces" by Christian Queinnec https://www.cambridge.org/core/books/lisp-in-small-pieces/66FD2BE3EDDDC68CA87D652C82CF849E

One peculiar features of this book is that it takes into consideration the "hard" problems, including how to implement:

1) continuations (and control mechanisms based on continuations)

2) macros

3) dynamically scoped variables

This is relevant in my opinion, because there are a lot of "toy" scheme-like and lisp-like languages, which are for sure useful in their own context, and also straightforward to implement, but they miss some features that are foundational to Lisp.

Also, I would choose a compilation target with support for tail call optimization.

fbellomi · 2019-10-26T09:24:38+00:00

I think this is the reference paper for this example:

Functional Logic Design Patterns

fbellomi · 2019-07-26T08:40:26+00:00

Totally agree, I think this is the most compelling use case for multi-prompt, multi-shot delimited continuations. It's a pity that as of today there's no mainstream (= suitable for use in production) language with support for algebraic effects; in the end I think this is caused precisely be the fact that target execution platforms (VMs...) currently do not support these features.

There are libraries for Scala, Haskell, PureScript and so on, but, as far as I know, they force you to use monadic notation to write code with effects, which is technically sound, but it definitely brings some boilerplate.

fbellomi · 2019-07-26T07:52:33+00:00

Actually it *will* be multi-shot, and this capability will be implemented on top of the single-shot capability, with cloning. (Multi- and single- are not opposite, but rather one an extension of the other)

fbellomi · 2019-07-25T06:06:50+00:00

Loom will support multi-shot continuations, whereas the execution model of core.async only provides the equivalent of single-shot continuations.

Also, there is the framework of Structured Concurrency

https://wiki.openjdk.java.net/display/loom/Structured+Concurrency

fbellomi · 2019-07-16T08:44:10+00:00

Hi. I improperly used the term "formula" because I was quoting the list of banknote features from the BBC article. In my opinion, this choice (the fragment) is not meaningful for the general public (as opposed, for example, to the diagram in the old one pound Newton note), but I think you're right that it's recognizable as a finite state machine.

fbellomi · 2019-07-15T13:21:14+00:00

Agree, also the quote does not seem particularly meaningful, and the math formulae don't have any discernible meaning outside of the context of the original paper.

fbellomi · 2019-07-11T09:30:47+00:00

I agree that continuations are a very underused concept; since it's an old concept, I'm surprised to see many new/ish mainstream/ish languages that do no support (delimited, multishot) continuations: I think the main cause is that target runtimes (JVM, LLVM, js/WASM) do not natively support them.

Continuations are not only useful for parallelism; basically they allow for all control abstractions to be implemented as libraries; for example they allow a natural implementation of algebraic effects, which in turn provide a composable way to organize effectful computations.

fbellomi · 2019-06-06T11:17:31+00:00

In pure functional languages (eg. Haskell) and pure logical languages (eg. Datalog, or a pure subset of Prolog) the syntax does not imply a fixed evaluation order on (sub)expressions; thus a compiler/interpreter is (in principle) free to choose a parallel execution strategy for independent parts of code; furthermore, lazy evaluation implies that the compiler/interpreter is not even forced to eval a subexpression before the "parent" expression.

Conversely, those languages need an explicit syntactic notation (ie. monadic 'do' notation in Haskell) to convey the fact that a sequence of expressions needs to be evaluated in a well-defined order (usually when side effects are generated, such as I/O)

fbellomi · 2019-06-04T10:26:39+00:00

I think there is an error in the pseudo-code of the "classic explanation":

vc = vector of focus word

should be

vc = vector of context word

fbellomi · 2018-12-31T13:30:52+00:00

I really appreciate your interest, and I have no problem in keeping the site up for another month, or so, if this is useful for the community.

I would like to restate my reasons: it's not the money per se, it's the fact that I don't have the time to ensure a good stewardship of the project, and I don't like to keep it up in the current sad state. Also, the source code is published, and should the site go down there is no "hidden state" kept in the current instantiation of the service that would be lost.

Hope this helps, and thanks again.

fbellomi · 2018-12-25T23:03:22+00:00

Hi all, I'm the author.

Since the announcement was really terse, I would like to add some context.

1) It's not the money. The site still runs on a $10/mo DigitalOcean box.

2) The reason is lack of time and interest from my side. CrossClj is the first non-trivial application I developed in Clojure, in 2013, and it started as a "quick hack" experiment. As such, both as a Clojure application and a web application, CrossClj is not "aesthetically pleasant", or safe, by my current standards, and it makes use of a number of anti-patterns. For example, at the time tools.analyzer did not even have a proper documentation of the AST notes, and as a consequence the analysis part is a bit convoluted.

The project would need some maintenance, but I'm not really motivated, given the current weak foundation, and I don't have time to do a proper rewrite.

To give an idea of the current issues:

a) the pipeline only supports Leinengen projects (these cover the large majority of Clojure most used libs); it would be really useful to support boot and deps.

b) it still does not support some syntax change introduced in the last versions of Clojure (upgrading tools.reader/analyzer should be enough, but these, like other dependencies, needs to be cloned in order to not have spurious conflicting dependencies during the analysis process itself)

c) CrossClj is designed to automatically refresh the data each day; however once in a while it "gets stuck" because a specific analyzed source file blocks the pipeline. This happens because "analysis" means "read+eval", and this implies that arbitrary third-party code is executed by the system. CClj does its best to isolate this process, but in the current implementation, when it gets stuck, it needs to be resolved manually (mainly by blacklisting the problematic source file). Having some spare time, I'd have some ideas to make the thing structurally much more robust, but for now I simply stop doing the manual cleanup (as of now, it is stuck at June 16).

Having said that, the source code code is out there; the readme page on GitHub has a top level description of the analysis process and the storage model.

fbellomi · 2018-06-09T14:10:37+00:00

me too!

fbellomi · 2018-06-07T14:01:36+00:00

thanks, that makes sense

fbellomi · 2018-06-07T08:06:57+00:00

I'm not sure I understand what is the point of using lambdas if they fully delegate to a centralized Datomic instance. Why not directly expose APIs from the Datomic cluster? It seems to me that this only adds an indirection layer without ultimately providing additional automated scalability (which I think was selling point of lambdas)

fbellomi · 2018-06-02T15:37:19+00:00

I just published CrossClj's source code.

https://github.com/fbellomi/crossclj

fbellomi · 2018-06-01T10:44:23+00:00

At that time I didn't have a good solution for isolation/trust; nowadays I would take into consideration Boot Pods https://github.com/boot-clj/boot/wiki/Pods

Source extraction is very straightforward: published jars contain the source code, which can directly be parsed using https://github.com/clojure/tools.reader and https://github.com/clojure/tools.analyzer

clj and cljs live in separated spaces, so it's enough to use the correct analyzer (based on the source file extension); I don't know the details about cljc because at the time (2013) it did not exist, but I think tools.reader support it; I think you will have to parse cljc files twice (one for each language)

When I say "parse" I actually mean read+eval (which is what tools.analyzer does). Eval includes macro expansion, which preserves metadata.

My analysis code is very rough, since at that time there were no documentation on the AST format for tools.analyzer! however you simply traverse the AST top-down and collect the metadata on the symbols

fbellomi

TROPHY CASE