callme is a python amqp rpc module
Alternatives To Callme
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
Aiormq2179172 months ago106January 02, 202333otherPython
Pure python AMQP 0.9.1 asynchronous client library
Amqp Client163224 years ago12May 27, 201519mitScala
Simple fault-tolerant AMQP client written in Scala and based on Akka and the RabbitMQ java client
a month ago22otherC++
AMQP 0.9.1 implementation for Qt
Node Celery Ts85
10 months ago17February 20, 202020bsd-3-clauseTypeScript
TypeScript Celery client for Node
Haredo8021a day ago60May 10, 20226mitTypeScript
Node.js library for RabbitMQ
Humusamqp7810410 months ago14August 05, 20214mitPHP
PHP 7.4 AMQP library
Dart_amqp7142a month ago16October 16, 202110mitDart
Dart AMQP client implementing protocol version 0.9.1
Rjr681314 years ago21November 10, 201510apache-2.0Ruby
Ruby JSON-RPC Library - json-rpc server/client mechanisms over amqp, websockets, and other transports, written in ruby
6 years ago1gpl-2.0MQL5
Metatrader 4 / AMQP (RabbitMQ) bridge
Node Amqp Rpc4920127 years ago7May 07, 201411mitJavaScript
AMQP RPC driver for node. Tested on RabbitMQ.
Alternatives To Callme
Select To Compare

Alternative Project Comparisons

Callme - A python RPC module based on AMQP


Callme provides an easy way to do RPC over AMQP (Callme is the successor of QAM <>).

Key Features:

  • Easy to use;
  • Uses AMQP as transport protocol;
  • Support timeouts;
  • SSL support;
  • Supports remote exceptions;
  • OpenSource BSD-licensed;
  • Designed to support broker-side permission system.

Getting started with callme

A simple RPC Server which provides an add method:

import callme

def add(a, b):
    return a + b

server = callme.Server(server_id='fooserver',

server.register_function(add, 'add')

and a client which uses fooserver to add 1 + 1 and finally prints the result:

import callme

proxy = callme.Proxy(server_id='fooserver',

print proxy.add(1, 1)

There are optional parameters to fit different needs which are explained in depth in the Server and Proxy Documentation.

Examples are provided in the examples directory in the package.


The Proxy is not thread-safe, you must instantiate one Proxy per thread.

The Server is also not thread-safe as well. Instantiate one Server per thread.

Even if the Server is not thread-safe itself, it has the capability to use multi-threading. For each RPC Call a worker thread is started which significantly improves the call speed if multiple clients are calling the server simultaneously. To activate multi-threading on the server pass threading=True to the Server class.


It is possible to control the access to a RPC Server by the Broker. We use RabbitMQ as example because this is the broker we used for testing and development. To get the highest security out of the permission system it is recommended using separate vhost only for callme communication (if you have other amqp messages on your system on the same broker).

For a more in depth explanation why these permissions look how they are see Exchange Design.

Limit Server Permissions

To limit one server to only accept RPC Calls to its server_id and send result back to clients we use these permissions. Assumption the RPC server has its own user called carl on the rabbitmq broker.

rabbitmqctl set_permissions carl "server_fooserver_.*" "server_fooserver_.*|client_.*_ex_.*" "server_fooserver_.*"

Limit Client (Proxy) Permissions

To limit the Proxy to the server with the server_id fooserver (no other server can then be reached with this user) we use these permissions. Assumption the RPC proxy has its own user called olivia on the rabbitmq broker.

rabbitmqctl set_permissions olivia "client_olivia_.*" "client_olivia_.*|server_fooserver_ex" "client_olivia_.*"

To give the client access to another RPC server with server_id barserver we set the following permissions:

rabbitmqctl set_permissions olivia "client_olivia_.*" "client_olivia_.*|server_fooserver_ex|server_barserver_ex" "client_olivia_.*"

To give the client access to all RPC servers set the permission as follows:

rabbitmqctl set_permissions olivia "client_olivia_.*" "client_olivia_.*|server_.*_ex" "client_olivia_.*"


Callme uses kombu for communication between Proxy and Server. Callme transfers instances of the RpcResponse and RpcRequest to execute remote procedure calls (RPC). The instances of these classes are pickled by kombu and then transferred to the server or proxy.

Exchange Design

Every Proxy creates a Exchange and a Queue bound to the Exchange which has the form client_<amqp_user>_ex_<uid> and client_<amqp_user>_queue_<uid>. <uid> is generated on creation of the Proxy. All Queues and Exchanges are auto-deleted and non-durable.

Client Exchange and Queue are declared and bound by the client and server Exchange and Queue are declared and bound by the server.

The Exchange and Queue Design:

------------------------------       |       ----------------------------
|          Proxy             |       v       |          Server          |
|       User: olivia         |               |        User: carl        |
|       ------------         |               |        ----------        |
|                            |               |                          |
|         --- RPC Call--------------------------> server_fooserver_ex   |
|                            |               |        (Exchange)        |
|                            |               |            |             |
|                            |               |            |             |
|                            |               |            |             |
|                            |               |            v             |
|                            |               |                          |
|                            |               |   server_fooserver_queue |
|                            |               |         (Queue)          |
|                            |               |            |             |
|                            |               |            /             |
| client_olivia_ex_<uid>  <----- RPC Result --------------              |
|        (Exchange)          |               |                          |
|            |               |               |                          |
|            |               |               |                          |
|            v               |               |                          |
| client_olivia_queue_<uid>  |               |                          |
|         (Queue)            |               |                          |
|____________________________|               |__________________________|


At the moment there are two loggers present with the names callme.proxy and callme.server. Both are mostly used for debugging at the moment.

Bug Tracker

If you find any issues please report them on

Getting callme

You can get the python package on the Python Package Index.

The git repository is available at callme.


callme can be installed via the Python Package Index or from source.

Using easy_install to install callme:

$ easy_install callme

Using pip to install callme:

$ pip install callme

If you have downloaded a source tarball you can install it as follows:

$ python build
$ python install

Supported by

Wingware - The Python IDE (


We are welcome everyone who wants to contribute to callme. Development of callme happens at ceelian/callme.

Contributors (chronological order)


Callme is released under the BSD License. The full license text is in the root folder of the callme Package.

Popular Rpc Projects
Popular Amqp Projects
Popular Application Programming Interfaces Categories

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.
Rpc Server