How to interact with a non faststream application with REDIS without json format

[pbonneaudiabolocom]

Hello,

With v0.7, RedisJSONMessageParser was removed.

If you are connected to another python application using Faststream, no issue.
But what happen when you are discussing with an application without faststream ?

What contract can you use then ?

Is there any description of the binary contract in order to build it from another language or even python ?

Regards,
Pierre

[sueun-dev]

yeah, looks like 0.7 went binary-first for Redis. I checked current main (2ab5a2f) and ran the parser locally: RedisBroker() defaults to BinaryMessageFormatV1, and an encoded message starts with the 8-byte header 89 42 49 4e 0d 0a 1a 0a, then version 1, then big-endian offsets/headers, then the raw payload bytes.

For a non-FastStream producer, either emit that binary layout, or send plain raw bytes if you do not need FastStream headers/metadata; BinaryMessageFormatV1.parse(b"plain-bytes") falls back to (b"plain-bytes", {}). The docs page docs/en/redis/message_format.md also has Go/Java parser sketches.

[pbonneaudiabolocom]

Thanks for the doc:
https://github.com/ag2ai/faststream/blob/main/docs/docs/en/redis/message_format.md

Which BTW doesn't point to the python implementation, need to be found by the user by itself. I'll check later if I have time to find the right link and update that doc.

That migration makes no sense to me. Having metrics is a side things... and it would have been more clean to say, we do not provides metrics on JSON format than to remove it.

• whenever a contract is done between 2 applications, changing the format is a little nightmare implying 2 applications migrating at the exact same time.

It doesn't look professional at all...

Now, I'm stuck in 0.6.4 until all teams involved in my project find time to synchronously change the message format type. So nice...

[Lancetnik]

JsonFormat was deprecated since 0.5.48 (July 2025 - https://github.com/ag2ai/faststream/releases/tag/0.5.48) and it throws a DeprecationWarning when used. The documentation has examples for writing a BinaryFormat encoder/decoder in two languages - these references should be sufficient to implement an encoder in any language (especially with the use of LLM)

To provide some context: the deprecation warning has been in place for almost a year, and the removal in 0.7 was announced in advance. Since version 0.6 (October 2025 - https://github.com/ag2ai/faststream/releases/tag/0.6.0), BinaryFormat became the default behavior, with JsonFormat remaining available as an opt-in for backward compatibility during that transition period.

I understand that coordinating format migrations across multiple teams can be challenging - that's exactly why we tried to provide a long transition window. If you have feedback on how the deprecation or migration path could have been communicated more clearly, we'd be happy to hear it. This kind of discussion would have been great to have at the 0.5.48 or 0.6.0 release stages so we could have addressed concerns earlier.

[pbonneaudiabolocom]

I'm sorry to disapoint you, but a bad idea, even taken long ago, stays a bad idea.

I actually never imagined that a lib would deprecate for real something simple and open in favor of a closed complex code.

The biggest strengh of faststream was : get an object, give a pydantic model, make that object pass through the system.
Cross platform, no issue.

Now, I have to go to all other service, and ask them to migrate to a binary format nobody has, all at the same time, consumers and producers, in order to use one lib. I will have quite a had time convincing them.

All that for no benefit on our side. It brings absolutly no value.

[Lancetnik]

I believe we still have fallback to raw binary format (not-FastStream formatted), isn't it?

https://github.com/ag2ai/faststream/blob/main/tests/brokers/redis/test_parser.py
https://github.com/ag2ai/faststream/blob/main/faststream/redis/parser/binary.py#L94-L103

[Lancetnik]

And yes, we can fallback to raw JSON. Exactly for compatibility with external not-FastStream systems:

from dataclasses import dataclass

from faststream import FastStream, Logger
from faststream.redis import RedisBroker

broker = RedisBroker("redis://localhost:6379")
app = FastStream(broker)

@dataclass
class User:
    id: str
    name: str

@broker.subscriber("test")
async def test(user: User, logger: Logger) -> None:
    logger.info(user)

@app.after_startup
async def after_startup() -> None:
    await broker.publish(User(id="1", name="John"), "test")

    # Raw Redis publishing
    await broker._connection.publish("test", b'{"id": "1", "name": "John"}')

2026-06-05 19:32:32,837 INFO     - FastStream app starting...
2026-06-05 19:32:32,864 INFO     - test |            - `Test` waiting for messages
2026-06-05 19:32:32,868 INFO     - test | 762106be-c - Received
2026-06-05 19:32:32,868 INFO     - FastStream app started successfully! To exit, press CTRL+C
2026-06-05 19:32:32,868 INFO     - test | 762106be-c - User(id='1', name='John')
2026-06-05 19:32:32,868 INFO     - test | 762106be-c - Processed
2026-06-05 19:32:32,868 INFO     - test | ca401b21-b - Received
2026-06-05 19:32:32,869 INFO     - test | ca401b21-b - User(id='1', name='John')
2026-06-05 19:32:32,869 INFO     - test | ca401b21-b - Processed

[pbonneaudiabolocom]

Very interesting.
If I understand, the logic is

try binary reader (failing for json)
go in exception
Try to open it as json

It could definitly do the job.

Could we somehow make it explicit and not backoff to an Exception mechanism ?
Having binary format first is not issue for me, and actually, we do use it when we can.

But keeping the possibility to use, maybe at the subscriber level, the posisbility to have a legacy / compatible JSONmessage, would make sense.

[pbonneaudiabolocom]

I mean, for log term, it would make more sence to have it explicitly in the code than to rely on an exception that could change one day.

[Lancetnik]

You can provide any message_format implementation you want. It is still public option. At least you can just copy previous JsonMessageFormat codec from faststream<0.7 and use it from your code as your own class

Another example:

from faststream.redis.parser import MessageFormat

class RawMessage(MessageFormat):
    @classmethod
    async def encode(cls, message: User, **kwargs: Any) -> bytes:
        return json.dumps(asdict(message)).encode()

@broker.subscriber("test")
@broker.publisher("test", message_format=RawMessage)
async def test(
    user: User,
    logger: Logger,
) -> User:
    logger.info(user)
    return user

This way you can control outgoing message format to interact with not-FastStream subscribers

[Lancetnik]

message_format is a subscriber / publisher / broker option. So, you can setup it any level you prefer

[pbonneaudiabolocom]

I forgot to mention that moving to 0.7 was in fine very easy due to that "backup" json message format mechanism.

I'll move another app soon I hope.