I'd answer this in a different way: object and graph databases work on two different amounts of abstraction.
An item database's primary data elements are objects, the way you know them from an item-oriented programming language.
A graph database's primary data elements are nodes and edges.
An item database doesn't have the idea of the (bidirectional) edge between a couple of things with automatic referential integrity etc. A graph database doesn't have the idea of the pointer that may be NULL. (Obviously it's possible to imagine hybrid cars.)
When it comes to schema, an item database's schema is regardless of the group of classes is incorporated in the application. A graph database's schema (whether implicit, by convention of the items String labels mean, or explicit, by declaration as models once we get it done in InfoGrid for instance) is in addition to the application. This causes it to be easier, for instance, to create multiple programs from the same data utilizing a graph database rather than an item database, since the schema is application-independent. However, utilizing a graph database you cannot you need to a random object and persist it.
Different tools for various jobs I'd think.
As Will descibes from another position, a graphdb could keep your computer data separated out of your application classes and objects. A graphdb also offers more built-in functionality to cope with graphs, clearly - like least path or deep traversals.
Another essential difference is the fact that inside a graphdb like neo4j you are able to traverse the graph according to relationship (edge) types and directions without loading the entire nodes (including node qualities/characteristics). Additionally, there are the option of using neo4j as after sales of the object db, still having the ability to make use of all the graphy stuff, see: jo4neo This project includes a different approach that may also count being an object db on the top of neo4j: neo4j.rb. A brand new option is by using Spring Data Graph, which provides graphdb support through annotations.
Exactly the same question was requested within the comments to this blogpost.
Yes, the API appears such as the major difference, however is not a real superficial one. Conceptually some objects will form a graph and also you could think about an API that goodies this graph inside a uniform way. On the other hand, you can theoretically mine a normal graph structure for designs and map these to objects uncovered via some API. But the appearance of the API of the actual product will normally have consequence how information is really saved, how it may be queried, so it might be not even close to trivial to, say, produce a wrapper making it seem like another thing. Also, an item-oriented database must offer some integrity guarantees along with a typing structure that the graph database will not normally do. Actually, serious OO database are not even close to "free-form" :)
Have a look at [HyperGraphDB] - it's both a complete object-oriented database (like db4o) along with a very advanced graph database both when it comes to representational and querying abilities. It is capable of doing storing generalized hypergraphs (where edges can indicate several node also to other edges too), it features a fully extensible type system embedded like a graph etc.
Unlike other graph databases, in HyperGraphDB every object turns into a node or perhaps an edge within the graph, with none-to-minimal API invasion and you've got the option of representing your objects like a graph or dealing with them in ways that's orthogonal towards the graph structure (as "payload" values of the nodes or edges). That you can do sophisticated traversals, personalized indexing and querying.
A reason why HyperGraphDB is actually an ODMS, begin to see the blog publish Is HyperGraphDB an OO Database? at Kobrix's website.